forked from Furumi/furumi-web
Added podcasts support
This commit is contained in:
1 parent
9b923851ae
commit
be7ccd5b4f
22 files changed
+2240
-45
No files matched your search
Generated
+57
-38
@@ -453,6 +453,12 @@ version = "0.22.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
|
||||
|
||||
[[package]]
|
||||
name = "base64"
|
||||
version = "0.23.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "ac07cdecf99051d9a5238b80f35af32cdeba5b336e55d957b318b50137e18da5"
|
||||
|
||||
[[package]]
|
||||
name = "base64ct"
|
||||
version = "1.8.3"
|
||||
@@ -805,9 +811,9 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
|
||||
|
||||
[[package]]
|
||||
name = "combine"
|
||||
version = "4.6.8"
|
||||
version = "4.6.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "cfc320937d09e6de266b31b9afb480f197d7a861be86be7cb2ea7e5d1bfffc5e"
|
||||
checksum = "4356eba6976435498d05a311ee9fc486da3bc81c200d3f0d7dd9703b41913f92"
|
||||
dependencies = [
|
||||
"bytes",
|
||||
"memchr",
|
||||
@@ -2161,9 +2167,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "generator"
|
||||
version = "0.8.9"
|
||||
version = "0.8.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b3b854b0e584ead1a33f18b2fcad7cf7be18b3875c78816b753639aa501513ae"
|
||||
checksum = "1be81b31c9ce4caf7f3178eeb90662bb1864d3ad363ec6bdada3201adff19c37"
|
||||
dependencies = [
|
||||
"cc",
|
||||
"cfg-if",
|
||||
@@ -3351,9 +3357,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "js-sys"
|
||||
version = "0.3.104"
|
||||
version = "0.3.106"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0e0c1080212aad755ea003d18543e8768dd432c48819efd73a7bf1e39b7a5a3a"
|
||||
checksum = "7883d941dae510fb2d978fc3fe018c71c9e2892fd38854de3e8b92c2e5ad9cc5"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"futures-util",
|
||||
@@ -3403,9 +3409,9 @@ checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
|
||||
|
||||
[[package]]
|
||||
name = "libredox"
|
||||
version = "0.1.23"
|
||||
version = "0.1.25"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "8d8f1ea3f21fd3405dcaf6c9b5c1630af9afc422d9073ea39c5f6d6c772e08ed"
|
||||
checksum = "61ff90caf6077a803a240f62fdbe88645a890bbca49ef8174c3cb0404362171d"
|
||||
dependencies = [
|
||||
"bitflags 2.13.1",
|
||||
"libc",
|
||||
@@ -3900,16 +3906,18 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "music-dht"
|
||||
version = "0.5.0"
|
||||
version = "0.6.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4c3f75d49d3a742a6777a1c4cc53f397399dfc9ddb70034c57aeb44d75d2ee4f"
|
||||
checksum = "7ce81f361952228654c28a46e41555f2c3d1520bf8c6c76562e7a53f70dd38e1"
|
||||
dependencies = [
|
||||
"async-trait",
|
||||
"blake3",
|
||||
"data-encoding",
|
||||
"encoding_rs",
|
||||
"federation-net",
|
||||
"futures",
|
||||
"postcard",
|
||||
"quick-xml 0.41.0",
|
||||
"rand 0.9.5",
|
||||
"rusqlite",
|
||||
"serde",
|
||||
@@ -3918,6 +3926,7 @@ dependencies = [
|
||||
"tokio",
|
||||
"tracing",
|
||||
"unicode-normalization",
|
||||
"url",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -4040,9 +4049,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "netdev"
|
||||
version = "0.46.2"
|
||||
version = "0.46.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "4db4135b187ddae3b6813c4f9d9ac9d5181859fa6a08b4e006c63a130974ed62"
|
||||
checksum = "c3c52c2584961c68f5a6e3356797344061f818c93b8acc9cd6d7e284795e563e"
|
||||
dependencies = [
|
||||
"block2",
|
||||
"dispatch2",
|
||||
@@ -4158,7 +4167,7 @@ dependencies = [
|
||||
"n0-future",
|
||||
"n0-watcher",
|
||||
"netdev 0.45.0",
|
||||
"netdev 0.46.2",
|
||||
"netdev 0.46.3",
|
||||
"netlink-packet-core 0.8.2",
|
||||
"netlink-packet-route 0.31.0",
|
||||
"netlink-proto",
|
||||
@@ -4456,9 +4465,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "objc2"
|
||||
version = "0.6.4"
|
||||
version = "0.6.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3a12a8ed07aefc768292f076dc3ac8c48f3781c8f2d5851dd3d98950e8c5a89f"
|
||||
checksum = "08849bbd4767dfae9457696856ae1c84fe4e0281bbe4a7abff2d0e06fb7981f8"
|
||||
dependencies = [
|
||||
"objc2-encode",
|
||||
]
|
||||
@@ -4633,9 +4642,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "openssl-probe"
|
||||
version = "0.2.1"
|
||||
version = "0.2.2"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7c87def4c32ab89d880effc9e097653c8da5d6ef28e6b539d313baaacfbafcbe"
|
||||
checksum = "7e036b411754132fd6b74e94b74e9a13c5cf606fa93d1885c35860d3060820b1"
|
||||
|
||||
[[package]]
|
||||
name = "openssl-sys"
|
||||
@@ -4927,13 +4936,13 @@ checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
|
||||
|
||||
[[package]]
|
||||
name = "plist"
|
||||
version = "1.10.0"
|
||||
version = "1.10.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7da1d65da6dd5d1e44199ac0f58712d241c0f439f80adea8924d832384087f85"
|
||||
checksum = "327a4cb2ad49dc48adfdc9da89e22c64d488b508c67a044d71ba729e4521a285"
|
||||
dependencies = [
|
||||
"base64 0.22.1",
|
||||
"base64 0.23.1",
|
||||
"indexmap 2.14.1",
|
||||
"quick-xml 0.41.0",
|
||||
"quick-xml 0.42.0",
|
||||
"serde",
|
||||
"time",
|
||||
]
|
||||
@@ -5175,6 +5184,15 @@ dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quick-xml"
|
||||
version = "0.42.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "41b1177fdf999d2321d3fb46ff47159d9c1fb9ad66a4879f8c50a0b504615e9b"
|
||||
dependencies = [
|
||||
"memchr",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "quinn"
|
||||
version = "0.11.11"
|
||||
@@ -5669,9 +5687,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "rustix"
|
||||
version = "1.1.4"
|
||||
version = "1.1.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
|
||||
checksum = "891efababe418670775f199f0d233d84843c227a0949a883ce15b37c78d6629d"
|
||||
dependencies = [
|
||||
"bitflags 2.13.1",
|
||||
"errno",
|
||||
@@ -7763,9 +7781,9 @@ checksum = "b8dad83b4f25e74f184f64c43b150b91efe7647395b42289f38e50566d82855b"
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen"
|
||||
version = "0.2.127"
|
||||
version = "0.2.129"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "1b70935747edd64d89de3efa29d73789b806c15798f8e7dca4d8ac356b50ce70"
|
||||
checksum = "9bb54f33acc68fd454578d9820b0bde1a1a3d17aa17bb7b6595806d02886d409"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"once_cell",
|
||||
@@ -7776,19 +7794,20 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-futures"
|
||||
version = "0.4.77"
|
||||
version = "0.4.79"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6b7777d5cc23d0e91404e53ce2d5e8ec7acae3026b16233dba62cd3246457950"
|
||||
checksum = "3cbab34de2d982e9b48e18d216d04c4a6f641066ff19ffb699980f591ee3610e"
|
||||
dependencies = [
|
||||
"js-sys",
|
||||
"tokio",
|
||||
"wasm-bindgen",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro"
|
||||
version = "0.2.127"
|
||||
version = "0.2.129"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "77775f8f3f7217702089053b94958f8f54061a3f663417df76e19cbdcca29bc1"
|
||||
checksum = "2e29d0c35b16e224a7eeb5cd2d25e3e1968fbd65604117b44d3b789d00ee8535"
|
||||
dependencies = [
|
||||
"quote",
|
||||
"wasm-bindgen-macro-support",
|
||||
@@ -7796,22 +7815,22 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-macro-support"
|
||||
version = "0.2.127"
|
||||
version = "0.2.129"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "e11d33f857dc2fb11b8bc75aee111aa9cbeb12cd9f25efd3d4c2a3dd4e235284"
|
||||
checksum = "6f501a8bc3719dba86ef8ae4728879c08001bea749eb1333ac5b91e040e2a6b7"
|
||||
dependencies = [
|
||||
"bumpalo",
|
||||
"proc-macro2",
|
||||
"quote",
|
||||
"syn 2.0.119",
|
||||
"syn 3.0.4",
|
||||
"wasm-bindgen-shared",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "wasm-bindgen-shared"
|
||||
version = "0.2.127"
|
||||
version = "0.2.129"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "7ef64dbcc55df09c7e5a46182d181c2cfa3e925f3da937ea764728b4bbb9dcbf"
|
||||
checksum = "23f0c9c52aa7cd7d77769a4cfe2a9adb1b331f489a41d912ce14513d5ab995c6"
|
||||
dependencies = [
|
||||
"unicode-ident",
|
||||
]
|
||||
@@ -7844,9 +7863,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "web-sys"
|
||||
version = "0.3.104"
|
||||
version = "0.3.106"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "c435338968042f4f59a557f690a253676d47ce13ceb55d70100e7facf6620a30"
|
||||
checksum = "88261b9deccee56594c11a3460c462c41f58d148598fe70ad77070126a68aba4"
|
||||
dependencies = [
|
||||
"js-sys",
|
||||
"wasm-bindgen",
|
||||
@@ -7864,9 +7883,9 @@ dependencies = [
|
||||
|
||||
[[package]]
|
||||
name = "webpki-root-certs"
|
||||
version = "1.0.9"
|
||||
version = "1.0.11"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b96554aa2acc8ccdb7e1c9a58a7a68dd5d13bccc69cd124cb09406db612a1c9b"
|
||||
checksum = "e49d0e65abc00c142e8f9428da991da9f1a250c39be97459901eb12b9b49f62a"
|
||||
dependencies = [
|
||||
"rustls-pki-types",
|
||||
]
|
||||
|
||||
+2
-2
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "furumusic"
|
||||
version = "0.12.4"
|
||||
version = "0.12.5"
|
||||
edition = "2024"
|
||||
description = "Reusable web-app boilerplate: auth, OIDC/SSO, admin panel, user management, i18n, PostgreSQL"
|
||||
|
||||
@@ -56,4 +56,4 @@ 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 = { version = "0.6.0", features = ["podcast-feed"] }
|
||||
@@ -2,6 +2,38 @@
|
||||
|
||||
[Project overview](../README.md) · [Installation](setup.md) · [Development and tests](development.md)
|
||||
|
||||
## Podcasts
|
||||
|
||||
The player's **Podcasts** entry below **My uploads** manages RSS/Atom subscriptions.
|
||||
Subscriptions start private. Publishing shares a feed card with other instance users
|
||||
and, while federation is enabled, the Frid podcast discovery overlay. Network search
|
||||
uses the same overlay as Furumi TUI; subscribing fetches the origin feed itself rather
|
||||
than trusting a publisher's claimed redirect or episode metadata. Feed URLs that may
|
||||
contain private access tokens require an additional confirmation before publication.
|
||||
|
||||
The catalogue and downloaded audio are shared by the instance. Unsubscribing removes
|
||||
only that user's subscription and publication; other subscribers keep their access.
|
||||
Listening position and played status are personal. Playback can begin from the source
|
||||
while a separate download saves the episode on the server. Cached episodes play from
|
||||
the server even when the publisher is unavailable; a connection to this server is
|
||||
still required.
|
||||
|
||||
The internal **podcast_refresh** job checks subscribed feeds every 30 minutes and
|
||||
downloads missing episodes, retrying failed downloads on later runs. Its schedule can
|
||||
be changed in the normal job settings. A manual check makes new episode metadata
|
||||
available before the audio download finishes. Up to three downloads run concurrently;
|
||||
each episode is limited to 2 GiB. Podcast sources must resolve to public HTTP(S)
|
||||
addresses, including after redirects.
|
||||
|
||||
**Settings → Podcasts → Manage podcasts** lists every known podcast, subscriber and
|
||||
publication counts, and saved episode counts. Administrators can check a feed, remove
|
||||
its publications, clear saved audio, or delete the podcast for every user. Audio
|
||||
retention is disabled by default. When enabled, its day count is measured from the
|
||||
download time; the periodic job removes old audio while keeping episode descriptions
|
||||
and listening progress. Removed audio is downloaded again only on an explicit save
|
||||
or playback request. Podcast personal state is not replicated to trusted Frid devices
|
||||
yet; device synchronization continues to advertise protocol v3.
|
||||
|
||||
## Access and public sharing
|
||||
|
||||
OIDC identifies accounts by issuer and subject. Matching admin groups take
|
||||
|
||||
@@ -55,6 +55,18 @@ FURUMUSIC_LASTFM_TEST_DATABASE_URL=postgres://user:pass@localhost/test_db \
|
||||
|
||||
## Access and sharing tests
|
||||
|
||||
Podcast regressions include browser-store tests in `tests/podcasts.test.cjs` and an
|
||||
isolated PostgreSQL fixture for multiuser subscriptions, progress generations,
|
||||
retention and administrator actions:
|
||||
|
||||
```bash
|
||||
node --test tests/podcasts.test.cjs
|
||||
FURU_PODCAST_TEST_DATABASE_URL=postgresql://... cargo test podcasts -- --include-ignored
|
||||
```
|
||||
|
||||
Use a disposable database. The PostgreSQL test creates and drops a unique schema;
|
||||
its audio files use a unique temporary directory. Normal podcast tests need no network.
|
||||
|
||||
The access regression suite uses a disposable migrated database and a local OIDC
|
||||
provider with signed tokens and PKCE:
|
||||
|
||||
|
||||
@@ -5,8 +5,8 @@ use std::time::Duration;
|
||||
use anyhow::Result;
|
||||
use music_dht::StreamAcceptor;
|
||||
use music_dht::capabilities::{
|
||||
CAPABILITIES_PROTOCOL_VERSION, CapabilityManifest, CapabilityMessage, JAM_ID, SIMILARITY_ID,
|
||||
read_message, write_message,
|
||||
CAPABILITIES_PROTOCOL_VERSION, CapabilityManifest, CapabilityMessage, DEVICE_SYNC_ID, JAM_ID,
|
||||
SIMILARITY_ID, read_message, write_message,
|
||||
};
|
||||
|
||||
use super::serve::AUDIO_PROTOCOL_VERSION;
|
||||
@@ -15,6 +15,8 @@ fn local_manifest() -> CapabilityManifest {
|
||||
CapabilityManifest::frid("furumusic", env!("CARGO_PKG_VERSION"))
|
||||
// The web server does not expose federation Jam yet.
|
||||
.without_protocol(JAM_ID)
|
||||
// Podcast discovery is supported, but personal device sync remains v3.
|
||||
.with_protocol(DEVICE_SYNC_ID, super::devices::PROTOCOL_VERSION)
|
||||
.with_protocol("audio", AUDIO_PROTOCOL_VERSION)
|
||||
.with_protocol(
|
||||
SIMILARITY_ID,
|
||||
|
||||
@@ -27,7 +27,7 @@ use super::{TransportStats, record_stream_transport};
|
||||
pub const SYNC_ALPN: &[u8] = b"furumi/sync/2";
|
||||
|
||||
const CLIENT_VERSION: &str = env!("CARGO_PKG_VERSION");
|
||||
const PROTOCOL_VERSION: u16 = 3;
|
||||
pub(super) const PROTOCOL_VERSION: u16 = 3;
|
||||
const INVITE_TTL_MS: i64 = 10 * 60 * 1000;
|
||||
const PAIRING_WAIT_MS: i64 = 5 * 60 * 1000;
|
||||
const PAIRING_RETRY_DELAY: Duration = Duration::from_secs(1);
|
||||
|
||||
@@ -30,6 +30,7 @@ use std::time::{Duration, Instant};
|
||||
|
||||
use anyhow::{Context, Result};
|
||||
use music_dht::capabilities::CAPABILITIES_ALPN;
|
||||
use music_dht::podcast_dht::{PODCAST_DHT_ALPN, PodcastDht};
|
||||
use music_dht::similarity_dht::SimilarityDht;
|
||||
use music_dht::similarity_lsh::SIMILARITY_DHT_ALPN;
|
||||
use music_dht::{
|
||||
@@ -60,6 +61,7 @@ const TRANSPORT_SAMPLE_LIMIT: usize = 16;
|
||||
struct Running {
|
||||
service: Arc<MusicDhtService>,
|
||||
similarity_dht: Arc<SimilarityDht>,
|
||||
podcast_dht: Arc<PodcastDht>,
|
||||
network_name: String,
|
||||
tasks: Vec<tokio::task::JoinHandle<()>>,
|
||||
}
|
||||
@@ -498,6 +500,7 @@ impl Federation {
|
||||
.schema_independent_stream_protocol(SIMILARITY_ALPN)
|
||||
.schema_independent_stream_protocol(SIMILARITY_DHT_ALPN)
|
||||
.schema_independent_stream_protocol(CAPABILITIES_ALPN)
|
||||
.schema_independent_stream_protocol(PODCAST_DHT_ALPN)
|
||||
.build()
|
||||
.map_err(|err| anyhow::anyhow!("invalid federation config: {err}"))?;
|
||||
let (service, mut events) =
|
||||
@@ -511,6 +514,30 @@ impl Federation {
|
||||
"federation started"
|
||||
);
|
||||
|
||||
let podcast_dht = PodcastDht::open(
|
||||
Arc::clone(&service),
|
||||
self.data_dir.join("podcast-routing.sqlite3"),
|
||||
)
|
||||
.await?;
|
||||
let podcast_acceptor = service.stream_acceptor(PODCAST_DHT_ALPN)?;
|
||||
let podcast_serve_task = tokio::spawn(Arc::clone(&podcast_dht).serve(podcast_acceptor));
|
||||
let podcast_maintenance_task = tokio::spawn(Arc::clone(&podcast_dht).maintenance());
|
||||
let podcast_pool = pool.clone();
|
||||
let podcast_overlay = Arc::clone(&podcast_dht);
|
||||
let podcast_sync_task = tokio::spawn(async move {
|
||||
let mut interval = tokio::time::interval(SYNC_INTERVAL);
|
||||
interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
|
||||
loop {
|
||||
interval.tick().await;
|
||||
if crate::podcasts::reconcile(&podcast_pool, &podcast_overlay)
|
||||
.await
|
||||
.is_err()
|
||||
{
|
||||
tracing::warn!("podcast publication reconciliation failed; will retry");
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
let similarity_dht = SimilarityDht::open(
|
||||
Arc::clone(&service),
|
||||
self.data_dir.join("similarity-routing.sqlite3"),
|
||||
@@ -602,8 +629,12 @@ impl Federation {
|
||||
*guard = Some(Running {
|
||||
service,
|
||||
similarity_dht,
|
||||
podcast_dht,
|
||||
network_name,
|
||||
tasks: vec![
|
||||
podcast_serve_task,
|
||||
podcast_maintenance_task,
|
||||
podcast_sync_task,
|
||||
event_task,
|
||||
sync_task,
|
||||
audio_task,
|
||||
@@ -671,6 +702,29 @@ impl Federation {
|
||||
.context("federation is not running")
|
||||
}
|
||||
|
||||
pub async fn sync_podcasts(&self) -> Result<()> {
|
||||
let overlay = self
|
||||
.running
|
||||
.lock()
|
||||
.await
|
||||
.as_ref()
|
||||
.map(|r| Arc::clone(&r.podcast_dht))
|
||||
.context("federation is not running")?;
|
||||
crate::podcasts::reconcile(&self.pool().await?, &overlay).await
|
||||
}
|
||||
|
||||
pub async fn search_podcasts(&self, query: &str) -> Result<Value> {
|
||||
let overlay = self
|
||||
.running
|
||||
.lock()
|
||||
.await
|
||||
.as_ref()
|
||||
.map(|r| Arc::clone(&r.podcast_dht))
|
||||
.context("federation is not running")?;
|
||||
let hits = overlay.search(query, 100).await?;
|
||||
Ok(Value::Array(hits.into_iter().map(|hit| json!({"id":hit.podcast_id,"url":hit.feed_url,"metadata":{"title":hit.card.title,"author":hit.card.author,"description":hit.card.description}})).collect()))
|
||||
}
|
||||
|
||||
async fn similarity_services(&self) -> Result<(Arc<MusicDhtService>, Arc<SimilarityDht>)> {
|
||||
self.running
|
||||
.lock()
|
||||
|
||||
@@ -15,6 +15,7 @@ mod metrics;
|
||||
mod music;
|
||||
mod oidc;
|
||||
mod player;
|
||||
mod podcasts;
|
||||
mod scheduler;
|
||||
mod similarity;
|
||||
mod torrents;
|
||||
@@ -63,6 +64,7 @@ fn build_registry() -> Arc<JobRegistry> {
|
||||
registry.register(jobs::metadata_backfill::MetadataBackfillJob);
|
||||
registry.register(jobs::lastfm_popularity::LastfmPopularityJob);
|
||||
registry.register(jobs::lastfm_scrobble::LastfmScrobbleJob);
|
||||
registry.register(podcasts::PodcastRefreshJob);
|
||||
Arc::new(registry)
|
||||
}
|
||||
|
||||
@@ -579,6 +581,10 @@ impl Project for FuruProject {
|
||||
"/admin",
|
||||
);
|
||||
apps.register_with_views(api::ApiApp, "/api");
|
||||
apps.register_with_views(
|
||||
podcasts::PodcastApp::new(Arc::clone(&self.app_config)),
|
||||
"/api/podcasts",
|
||||
);
|
||||
apps.register_with_views(
|
||||
player::PlayerApp::new(
|
||||
Arc::clone(&self.app_config),
|
||||
|
||||
@@ -2838,6 +2838,33 @@ pub mod db_migrations {
|
||||
&[Operation::custom(add_import_playlist_destinations).build()];
|
||||
}
|
||||
|
||||
#[cot::db::migrations::migration_op]
|
||||
async fn create_podcasts(ctx: migrations::MigrationContext<'_>) -> cot::db::Result<()> {
|
||||
for statement in include_str!("../podcasts/schema.sql").split(';') {
|
||||
if !statement.trim().is_empty() {
|
||||
ctx.db.raw(statement).await?;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
#[derive(Debug, Copy, Clone)]
|
||||
pub struct M0054CreatePodcasts;
|
||||
impl migrations::Migration for M0054CreatePodcasts {
|
||||
const APP_NAME: &'static str = "furumusic";
|
||||
const MIGRATION_NAME: &'static str = "m_0054_create_podcasts";
|
||||
const DEPENDENCIES: &'static [migrations::MigrationDependency] = &[
|
||||
migrations::MigrationDependency::migration(
|
||||
"furumusic",
|
||||
"m_0052_add_import_playlist_destinations",
|
||||
),
|
||||
migrations::MigrationDependency::migration(
|
||||
"furumusic",
|
||||
"m_0053_local_approval_and_public_shares",
|
||||
),
|
||||
];
|
||||
const OPERATIONS: &'static [Operation] = &[Operation::custom(create_podcasts).build()];
|
||||
}
|
||||
|
||||
pub const MIGRATIONS: &[&SyncDynMigration] = &[
|
||||
&M0006CreateMediaFile,
|
||||
&M0007CreateArtist,
|
||||
@@ -2881,5 +2908,6 @@ pub mod db_migrations {
|
||||
&M0050CreateMetadataFixHistory,
|
||||
&M0051AddListenStatisticsIndexes,
|
||||
&M0052AddImportPlaylistDestinations,
|
||||
&M0054CreatePodcasts,
|
||||
];
|
||||
}
|
||||
+1
-1
@@ -5467,7 +5467,7 @@ fn hex_value(byte: u8) -> Option<u8> {
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
|
||||
pub(crate) fn parse_range(header: &str, file_size: u64) -> Option<(u64, u64)> {
|
||||
if file_size == 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
@@ -0,0 +1,486 @@
|
||||
//! Server-owned podcast catalogue and cache; subscriptions and progress are personal.
|
||||
mod web;
|
||||
pub use web::PodcastApp;
|
||||
|
||||
use crate::{
|
||||
config::AppConfig,
|
||||
scheduler::{Job, JobContext, JobLog},
|
||||
};
|
||||
use anyhow::{Context, Result, bail};
|
||||
use futures_util::StreamExt;
|
||||
use music_dht::podcast::feed::parse_feed_with_base;
|
||||
use music_dht::podcast::{
|
||||
EpisodeMeta, FeedUrl, KnownEpisode, PodcastId, PodcastMeta, ShareRecord, SubscriptionRecord,
|
||||
};
|
||||
use music_dht::podcast_dht::{PodcastCardSpec, PodcastDht, PodcastShareState};
|
||||
use serde_json::{Value, json};
|
||||
use sqlx::{PgPool, Row};
|
||||
use std::{net::IpAddr, path::PathBuf, time::Duration};
|
||||
use tokio::io::AsyncWriteExt;
|
||||
|
||||
const MAX_FEED_BYTES: usize = 16 * 1024 * 1024;
|
||||
const MAX_AUDIO_BYTES: u64 = 2 * 1024 * 1024 * 1024;
|
||||
|
||||
fn public_address(ip: IpAddr) -> bool {
|
||||
match ip {
|
||||
IpAddr::V4(ip) => {
|
||||
!(ip.is_private()
|
||||
|| ip.is_loopback()
|
||||
|| ip.is_link_local()
|
||||
|| ip.is_unspecified()
|
||||
|| ip.is_multicast()
|
||||
|| ip.is_broadcast()
|
||||
|| ip.octets()[0] == 0
|
||||
|| ip.octets()[0] >= 240
|
||||
|| (ip.octets()[0] == 100 && (64..=127).contains(&ip.octets()[1])))
|
||||
}
|
||||
IpAddr::V6(ip) => ip
|
||||
.to_ipv4_mapped()
|
||||
.map(|v| public_address(IpAddr::V4(v)))
|
||||
.unwrap_or_else(|| (ip.segments()[0] & 0xe000) == 0x2000),
|
||||
}
|
||||
}
|
||||
|
||||
/// Resolve and pin public addresses on every redirect, including enclosure requests.
|
||||
pub(super) async fn fetch(
|
||||
url: &str,
|
||||
range: Option<&str>,
|
||||
validators: Option<(&str, &str)>,
|
||||
) -> Result<reqwest::Response> {
|
||||
let mut url = reqwest::Url::parse(FeedUrl::parse(url)?.as_str())?;
|
||||
for _ in 0..8 {
|
||||
let host = url.host_str().context("missing host")?;
|
||||
let addresses: Vec<_> =
|
||||
tokio::net::lookup_host((host, url.port_or_known_default().context("missing port")?))
|
||||
.await?
|
||||
.collect();
|
||||
if addresses.is_empty() || addresses.iter().any(|a| !public_address(a.ip())) {
|
||||
bail!("podcast sources must use public internet addresses");
|
||||
}
|
||||
let client = reqwest::Client::builder()
|
||||
.no_proxy()
|
||||
.redirect(reqwest::redirect::Policy::none())
|
||||
.connect_timeout(Duration::from_secs(15))
|
||||
.timeout(Duration::from_secs(600))
|
||||
.user_agent(concat!("FuruMusic/", env!("CARGO_PKG_VERSION")))
|
||||
.resolve_to_addrs(host, &addresses)
|
||||
.build()?;
|
||||
let mut request = client.get(url.clone());
|
||||
if let Some(range) = range {
|
||||
request = request.header("Range", range);
|
||||
}
|
||||
if let Some((etag, modified)) = validators {
|
||||
if !etag.is_empty() {
|
||||
request = request.header("If-None-Match", etag);
|
||||
}
|
||||
if !modified.is_empty() {
|
||||
request = request.header("If-Modified-Since", modified);
|
||||
}
|
||||
}
|
||||
let response = request
|
||||
.send()
|
||||
.await
|
||||
.context("podcast source request failed")?;
|
||||
if response.status() == reqwest::StatusCode::NOT_MODIFIED {
|
||||
return Ok(response);
|
||||
}
|
||||
if response.status().is_redirection() {
|
||||
url = url.join(
|
||||
response
|
||||
.headers()
|
||||
.get("location")
|
||||
.context("redirect without location")?
|
||||
.to_str()?,
|
||||
)?;
|
||||
FeedUrl::parse(url.as_str())?;
|
||||
continue;
|
||||
}
|
||||
return response
|
||||
.error_for_status()
|
||||
.context("podcast source returned an error");
|
||||
}
|
||||
bail!("too many podcast redirects")
|
||||
}
|
||||
|
||||
async fn feed_bytes(response: reqwest::Response) -> Result<Vec<u8>> {
|
||||
if response
|
||||
.content_length()
|
||||
.is_some_and(|len| len > MAX_FEED_BYTES as u64)
|
||||
{
|
||||
bail!("feed is too large");
|
||||
}
|
||||
let mut bytes = Vec::new();
|
||||
let mut stream = response.bytes_stream();
|
||||
while let Some(chunk) = stream.next().await {
|
||||
let chunk = chunk?;
|
||||
if bytes.len() + chunk.len() > MAX_FEED_BYTES {
|
||||
bail!("feed is too large");
|
||||
}
|
||||
bytes.extend_from_slice(&chunk);
|
||||
}
|
||||
Ok(bytes)
|
||||
}
|
||||
|
||||
pub(super) fn cache_path(config: &AppConfig, id: &str) -> PathBuf {
|
||||
PathBuf::from(&config.agent_storage_dir)
|
||||
.join("podcasts")
|
||||
.join(blake3::hash(id.as_bytes()).to_hex().as_str())
|
||||
}
|
||||
|
||||
pub(super) async fn subscribe(pool: &PgPool, user: i64, input: &str) -> Result<String> {
|
||||
let origin = FeedUrl::from_user_input(input)?;
|
||||
let existing: Option<String> =
|
||||
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_alias WHERE url=$1")
|
||||
.bind(origin.as_str())
|
||||
.fetch_optional(pool)
|
||||
.await?;
|
||||
let id = if let Some(id) = existing {
|
||||
id
|
||||
} else {
|
||||
let response = fetch(origin.as_str(), None, None).await?;
|
||||
let final_url = FeedUrl::parse(response.url().as_str())?;
|
||||
let bytes = feed_bytes(response).await?;
|
||||
let feed = parse_feed_with_base(&bytes, Some(final_url.as_str()))?;
|
||||
let mut tx = pool.begin().await?;
|
||||
// Serialize identity resolution: two users subscribing via a redirect share one catalogue.
|
||||
sqlx::query("SELECT pg_advisory_xact_lock(73829531)")
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
let existing: Option<String> = sqlx::query_scalar(
|
||||
"SELECT podcast_id FROM furumusic__podcast_alias WHERE url=$1 OR url=$2 LIMIT 1",
|
||||
)
|
||||
.bind(origin.as_str())
|
||||
.bind(final_url.as_str())
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
let id = existing.unwrap_or_else(|| PodcastId::from_feed_url(&origin).as_str().to_owned());
|
||||
sqlx::query("INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$3,$4) ON CONFLICT(id) DO NOTHING")
|
||||
.bind(&id).bind(origin.as_str()).bind(final_url.as_str()).bind(serde_json::to_value(feed.to_podcast_meta(final_url.clone()))?).execute(&mut *tx).await?;
|
||||
for url in [&origin, &final_url] {
|
||||
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(url.as_str()).bind(&id).execute(&mut *tx).await?;
|
||||
}
|
||||
tx.commit().await?;
|
||||
id
|
||||
};
|
||||
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(user).bind(&id).execute(pool).await?;
|
||||
Ok(id)
|
||||
}
|
||||
|
||||
pub(super) async fn refresh(pool: &PgPool, id: &str) -> Result<usize> {
|
||||
let result = tokio::time::timeout(Duration::from_secs(60), refresh_inner(pool, id))
|
||||
.await
|
||||
.unwrap_or_else(|_| Err(anyhow::anyhow!("feed check timed out")));
|
||||
if result.is_err() {
|
||||
sqlx::query("UPDATE furumusic__podcast SET checked_at=now(),last_error='Feed check failed; retry later' WHERE id=$1").bind(id).execute(pool).await?;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
async fn refresh_inner(pool: &PgPool, id: &str) -> Result<usize> {
|
||||
let mut tx = pool.begin().await?;
|
||||
sqlx::query("SELECT pg_advisory_xact_lock(hashtextextended($1,7391))")
|
||||
.bind(id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
let row = sqlx::query("SELECT * FROM furumusic__podcast WHERE id=$1 FOR UPDATE")
|
||||
.bind(id)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
let url: String = row.get("feed_url");
|
||||
let etag: Option<String> = row.get("etag");
|
||||
let modified: Option<String> = row.get("modified");
|
||||
let response = fetch(
|
||||
&url,
|
||||
None,
|
||||
Some((
|
||||
etag.as_deref().unwrap_or(""),
|
||||
modified.as_deref().unwrap_or(""),
|
||||
)),
|
||||
)
|
||||
.await?;
|
||||
if response.status() == reqwest::StatusCode::NOT_MODIFIED {
|
||||
sqlx::query("UPDATE furumusic__podcast SET checked_at=now(),last_error=NULL WHERE id=$1")
|
||||
.bind(id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
return Ok(0);
|
||||
}
|
||||
let final_url = FeedUrl::parse(response.url().as_str())?;
|
||||
let etag = response
|
||||
.headers()
|
||||
.get("etag")
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.map(str::to_owned);
|
||||
let modified = response
|
||||
.headers()
|
||||
.get("last-modified")
|
||||
.and_then(|v| v.to_str().ok())
|
||||
.map(str::to_owned);
|
||||
let bytes = feed_bytes(response).await?;
|
||||
let feed = parse_feed_with_base(&bytes, Some(final_url.as_str()))?;
|
||||
let podcast_id: PodcastId = serde_json::from_value(json!(id))?;
|
||||
let stored: Vec<Value> =
|
||||
sqlx::query_scalar("SELECT metadata FROM furumusic__podcast_episode WHERE podcast_id=$1")
|
||||
.bind(id)
|
||||
.fetch_all(&mut *tx)
|
||||
.await?;
|
||||
let known: Vec<_> = stored
|
||||
.into_iter()
|
||||
.map(serde_json::from_value::<EpisodeMeta>)
|
||||
.collect::<std::result::Result<Vec<_>, _>>()?
|
||||
.into_iter()
|
||||
.map(|meta| KnownEpisode {
|
||||
episode_id: meta.episode_id.clone(),
|
||||
hints: meta.identity_hints(),
|
||||
})
|
||||
.collect();
|
||||
let ids = feed.resolve_episode_ids(&podcast_id, &known);
|
||||
let mut added = 0;
|
||||
for (episode, episode_id) in feed.episodes.iter().zip(ids) {
|
||||
let Some(episode_id) = episode_id else {
|
||||
continue;
|
||||
};
|
||||
let meta = episode.to_meta(&podcast_id, episode_id.clone());
|
||||
let inserted: bool = sqlx::query_scalar("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3) ON CONFLICT(id) DO UPDATE SET metadata=EXCLUDED.metadata RETURNING (xmax=0)").bind(episode_id.as_str()).bind(id).bind(serde_json::to_value(meta)?).fetch_one(&mut *tx).await?;
|
||||
added += usize::from(inserted);
|
||||
}
|
||||
for alias in [
|
||||
Some(final_url.clone()),
|
||||
feed.new_feed_url
|
||||
.as_deref()
|
||||
.and_then(|u| FeedUrl::parse(u).ok()),
|
||||
]
|
||||
.into_iter()
|
||||
.flatten()
|
||||
{
|
||||
sqlx::query("INSERT INTO furumusic__podcast_alias(url,podcast_id) VALUES($1,$2) ON CONFLICT DO NOTHING").bind(alias.as_str()).bind(id).execute(&mut *tx).await?;
|
||||
}
|
||||
let next_url = feed
|
||||
.new_feed_url
|
||||
.as_deref()
|
||||
.and_then(|u| FeedUrl::parse(u).ok())
|
||||
.unwrap_or(final_url.clone());
|
||||
let moved = next_url != final_url;
|
||||
sqlx::query("UPDATE furumusic__podcast SET feed_url=$2,metadata=$3,etag=$4,modified=$5,checked_at=now(),last_error=NULL WHERE id=$1")
|
||||
.bind(id).bind(next_url.as_str()).bind(serde_json::to_value(feed.to_podcast_meta(next_url.clone()))?).bind(if moved {None} else {etag}).bind(if moved {None} else {modified}).execute(&mut *tx).await?;
|
||||
tx.commit().await?;
|
||||
Ok(added)
|
||||
}
|
||||
|
||||
pub(super) async fn download(
|
||||
pool: &PgPool,
|
||||
config: &AppConfig,
|
||||
id: &str,
|
||||
force: bool,
|
||||
) -> Result<()> {
|
||||
static DOWNLOADS: tokio::sync::Semaphore = tokio::sync::Semaphore::const_new(3);
|
||||
let _permit = DOWNLOADS.acquire().await?;
|
||||
let podcast: Option<String> =
|
||||
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_episode WHERE id=$1")
|
||||
.bind(id)
|
||||
.fetch_optional(pool)
|
||||
.await?;
|
||||
let Some(podcast) = podcast else {
|
||||
return Ok(());
|
||||
};
|
||||
let mut cache_guard = pool.begin().await?;
|
||||
sqlx::query("SELECT pg_advisory_xact_lock_shared(hashtextextended($1,7421))")
|
||||
.bind(&podcast)
|
||||
.execute(&mut *cache_guard)
|
||||
.await?;
|
||||
let meta: Option<Value> = sqlx::query_scalar("UPDATE furumusic__podcast_episode SET download_until=now()+interval '15 minutes',download_error=NULL WHERE id=$1 AND cached_at IS NULL AND (download_until IS NULL OR download_until<now()) AND ($2 OR (NOT expired AND (retry_at IS NULL OR retry_at<now()))) RETURNING metadata")
|
||||
.bind(id).bind(force).fetch_optional(pool).await?;
|
||||
let Some(meta) = meta else { return Ok(()) };
|
||||
let meta: EpisodeMeta = serde_json::from_value(meta)?;
|
||||
let path = cache_path(config, id);
|
||||
let temporary = path.with_extension("part");
|
||||
let result: Result<()> = tokio::time::timeout(Duration::from_secs(12 * 60), async {
|
||||
tokio::fs::create_dir_all(path.parent().context("missing cache directory")?).await?;
|
||||
let response = fetch(&meta.audio_url, None, None).await?;
|
||||
if response.content_length().is_some_and(|len| len > MAX_AUDIO_BYTES) { bail!("episode exceeds 2 GiB limit"); }
|
||||
let expected = response.content_length();
|
||||
let mut stream = response.bytes_stream();
|
||||
let mut file = tokio::fs::File::create(&temporary).await?;
|
||||
let mut length = 0;
|
||||
while let Some(chunk) = stream.next().await {
|
||||
let chunk = chunk?;
|
||||
length += chunk.len() as u64;
|
||||
if length > MAX_AUDIO_BYTES { bail!("episode exceeds 2 GiB limit"); }
|
||||
file.write_all(&chunk).await?;
|
||||
}
|
||||
if length == 0 || expected.is_some_and(|size| size != length) { bail!("incomplete episode download"); }
|
||||
file.flush().await?;
|
||||
drop(file);
|
||||
tokio::fs::rename(&temporary, &path).await?;
|
||||
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now(),download_until=NULL,retry_at=NULL,download_error=NULL,expired=false WHERE id=$1").bind(id).execute(pool).await?;
|
||||
Ok(())
|
||||
}).await.unwrap_or_else(|_| Err(anyhow::anyhow!("episode download timed out")));
|
||||
if result.is_err() {
|
||||
let _ = tokio::fs::remove_file(&temporary).await;
|
||||
sqlx::query("UPDATE furumusic__podcast_episode SET download_until=NULL,retry_at=now()+interval '30 minutes',download_error='Download failed; will retry' WHERE id=$1").bind(id).execute(pool).await?;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
pub(super) async fn download_pending(
|
||||
pool: &PgPool,
|
||||
config: &AppConfig,
|
||||
podcast: Option<&str>,
|
||||
) -> Result<()> {
|
||||
let ids: Vec<String> = sqlx::query_scalar("SELECT e.id FROM furumusic__podcast_episode e WHERE cached_at IS NULL AND NOT expired AND ($1::text IS NULL OR podcast_id=$1) AND EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=e.podcast_id) AND (retry_at IS NULL OR retry_at<now()) ORDER BY discovered_at DESC LIMIT 100").bind(podcast).fetch_all(pool).await?;
|
||||
futures_util::stream::iter(ids)
|
||||
.for_each_concurrent(3, |id| async move {
|
||||
let _ = download(pool, config, &id, false).await;
|
||||
})
|
||||
.await;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub async fn reconcile(pool: &PgPool, overlay: &PodcastDht) -> Result<()> {
|
||||
// Read the desired set only after acquiring the gate. An older pass must
|
||||
// never publish its snapshot after a completed share-off/unsubscribe pass.
|
||||
static GATE: tokio::sync::Mutex<()> = tokio::sync::Mutex::const_new(());
|
||||
let _guard = GATE.lock().await;
|
||||
let rows = sqlx::query("SELECT p.*,s.confirmed_urls FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE s.shared ORDER BY p.id").fetch_all(pool).await?;
|
||||
let mut states = std::collections::BTreeMap::new();
|
||||
for row in rows {
|
||||
let id: String = row.get("id");
|
||||
let meta: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
|
||||
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
|
||||
let sub = SubscriptionRecord {
|
||||
podcast_id: serde_json::from_value(json!(id))?,
|
||||
subscribed: true,
|
||||
podcast: meta,
|
||||
feed_aliases: vec![origin],
|
||||
generation: 1,
|
||||
hlc_ms: 1,
|
||||
op_id: "web-subscription".into(),
|
||||
};
|
||||
let card = PodcastCardSpec::from_subscription(&sub)?;
|
||||
let confirmed: Option<Value> = row.get("confirmed_urls");
|
||||
if !card.privacy_warnings().is_empty()
|
||||
&& confirmed != Some(json!([card.feed_url, card.id_feed_url]))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let share = ShareRecord {
|
||||
podcast_id: sub.podcast_id.clone(),
|
||||
shared: true,
|
||||
generation: 2,
|
||||
hlc_ms: 2,
|
||||
op_id: "web-share".into(),
|
||||
};
|
||||
states.insert(
|
||||
id,
|
||||
PodcastShareState {
|
||||
subscription: sub,
|
||||
share: Some(share),
|
||||
card: Some(card),
|
||||
privacy_confirmed: true,
|
||||
},
|
||||
);
|
||||
}
|
||||
overlay.sync_shares(states.into_values().collect()).await?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
pub struct PodcastRefreshJob;
|
||||
#[async_trait::async_trait]
|
||||
impl Job for PodcastRefreshJob {
|
||||
fn name(&self) -> &'static str {
|
||||
"podcast_refresh"
|
||||
}
|
||||
fn description(&self) -> &'static str {
|
||||
"Check subscribed podcast feeds, download episodes and enforce cache retention"
|
||||
}
|
||||
fn default_cron(&self) -> &'static str {
|
||||
"0 */30 * * * *"
|
||||
}
|
||||
async fn run(&self, ctx: &JobContext, log: &mut JobLog) -> Result<()> {
|
||||
let ids: Vec<String> =
|
||||
sqlx::query_scalar("SELECT DISTINCT podcast_id FROM furumusic__podcast_subscription")
|
||||
.fetch_all(&ctx.pool)
|
||||
.await?;
|
||||
let mut failed = 0;
|
||||
for id in &ids {
|
||||
if refresh(&ctx.pool, id).await.is_err() {
|
||||
failed += 1;
|
||||
sqlx::query("UPDATE furumusic__podcast SET last_error='Feed check failed',checked_at=now() WHERE id=$1").bind(id).execute(&ctx.pool).await?;
|
||||
}
|
||||
}
|
||||
download_pending(&ctx.pool, &ctx.config, None).await?;
|
||||
cleanup(&ctx.pool, &ctx.config).await?;
|
||||
let _ = crate::federation::handle().sync_podcasts().await;
|
||||
log.info(&format!(
|
||||
"Checked {} podcast feeds; {} failed",
|
||||
ids.len(),
|
||||
failed
|
||||
));
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
async fn cleanup(pool: &PgPool, config: &AppConfig) -> Result<()> {
|
||||
let days: Option<i32> =
|
||||
sqlx::query_scalar("SELECT retention_days FROM furumusic__podcast_settings WHERE id=1")
|
||||
.fetch_one(pool)
|
||||
.await?;
|
||||
let Some(days) = days else { return Ok(()) };
|
||||
let rows = sqlx::query(
|
||||
"SELECT id,podcast_id FROM furumusic__podcast_episode WHERE cached_at<now()-make_interval(days=>$1)",
|
||||
)
|
||||
.bind(days)
|
||||
.fetch_all(pool)
|
||||
.await?;
|
||||
for row in rows {
|
||||
let id: String = row.get("id");
|
||||
let podcast: String = row.get("podcast_id");
|
||||
let mut tx = pool.begin().await?;
|
||||
let locked: bool =
|
||||
sqlx::query_scalar("SELECT pg_try_advisory_xact_lock(hashtextextended($1,7421))")
|
||||
.bind(&podcast)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if !locked {
|
||||
continue;
|
||||
}
|
||||
let expired: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_episode WHERE id=$1 AND cached_at<now()-make_interval(days=>$2))").bind(&id).bind(days).fetch_one(&mut *tx).await?;
|
||||
if !expired {
|
||||
continue;
|
||||
}
|
||||
match tokio::fs::remove_file(cache_path(config, &id)).await {
|
||||
Ok(()) => {}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(_) => continue,
|
||||
}
|
||||
sqlx::query(
|
||||
"UPDATE furumusic__podcast_episode SET cached_at=NULL,expired=true WHERE id=$1",
|
||||
)
|
||||
.bind(id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn blocks_non_public_sources() {
|
||||
for ip in [
|
||||
"127.0.0.1",
|
||||
"10.1.1.1",
|
||||
"169.254.169.254",
|
||||
"100.64.0.1",
|
||||
"::1",
|
||||
"::ffff:127.0.0.1",
|
||||
"fc00::1",
|
||||
] {
|
||||
assert!(!public_address(ip.parse().unwrap()), "{ip}");
|
||||
}
|
||||
assert!(public_address("8.8.8.8".parse().unwrap()));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,32 @@
|
||||
CREATE TABLE IF NOT EXISTS furumusic__podcast (
|
||||
id TEXT PRIMARY KEY, origin_url TEXT NOT NULL UNIQUE, feed_url TEXT NOT NULL,
|
||||
metadata JSONB NOT NULL, etag TEXT, modified TEXT, checked_at TIMESTAMPTZ,
|
||||
last_error TEXT, created_at TIMESTAMPTZ NOT NULL DEFAULT now()
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS furumusic__podcast_alias (
|
||||
url TEXT PRIMARY KEY, podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS furumusic__podcast_subscription (
|
||||
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
|
||||
podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE,
|
||||
shared BOOLEAN NOT NULL DEFAULT false, confirmed_urls JSONB,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY(user_id,podcast_id)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS furumusic__podcast_episode (
|
||||
id TEXT PRIMARY KEY, podcast_id TEXT NOT NULL REFERENCES furumusic__podcast(id) ON DELETE CASCADE,
|
||||
metadata JSONB NOT NULL, discovered_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
cached_at TIMESTAMPTZ, download_until TIMESTAMPTZ, retry_at TIMESTAMPTZ,
|
||||
download_error TEXT, expired BOOLEAN NOT NULL DEFAULT false
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS idx_podcast_episode_feed ON furumusic__podcast_episode(podcast_id);
|
||||
CREATE TABLE IF NOT EXISTS furumusic__podcast_progress (
|
||||
user_id BIGINT NOT NULL REFERENCES furumusic__user(id) ON DELETE CASCADE,
|
||||
episode_id TEXT NOT NULL REFERENCES furumusic__podcast_episode(id) ON DELETE CASCADE,
|
||||
position_ms BIGINT NOT NULL DEFAULT 0, completed BOOLEAN NOT NULL DEFAULT false,
|
||||
generation BIGINT NOT NULL DEFAULT 0, checkpoint BIGINT NOT NULL DEFAULT 0,
|
||||
updated_at TIMESTAMPTZ NOT NULL DEFAULT now(), PRIMARY KEY(user_id,episode_id)
|
||||
);
|
||||
CREATE TABLE IF NOT EXISTS furumusic__podcast_settings (
|
||||
id INTEGER PRIMARY KEY CHECK(id=1), retention_days INTEGER CHECK(retention_days BETWEEN 1 AND 36500)
|
||||
);
|
||||
INSERT INTO furumusic__podcast_settings(id) VALUES(1) ON CONFLICT DO NOTHING;
|
||||
@@ -0,0 +1,282 @@
|
||||
use super::*;
|
||||
use cot::Template;
|
||||
|
||||
#[test]
|
||||
fn episode_routes_accept_encoded_colons_and_reject_invalid_ids() {
|
||||
let id = format!("ep1:{}", "a".repeat(52));
|
||||
assert_eq!(episode_path_id(&id).unwrap().as_str(), id);
|
||||
assert_eq!(
|
||||
episode_path_id(&id.replace(':', "%3A")).unwrap().as_str(),
|
||||
id
|
||||
);
|
||||
assert_eq!(
|
||||
episode_path_id(&id.replace(':', "%3a")).unwrap().as_str(),
|
||||
id
|
||||
);
|
||||
assert!(episode_path_id("../private").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn renders_podcast_navigation_and_views() {
|
||||
let html = crate::player::PlayerPageTemplate {
|
||||
t: crate::i18n::Translations::for_lang(crate::i18n::Lang::En),
|
||||
guest: false,
|
||||
share_token: String::new(),
|
||||
downloads_enabled: true,
|
||||
torrent_downloads_enabled: true,
|
||||
youtube_downloads_enabled: true,
|
||||
}
|
||||
.render()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
html.matches("@click=\"$store.podcasts.enter()\"").count(),
|
||||
2
|
||||
);
|
||||
assert!(html.contains("/api/podcasts/action"));
|
||||
if std::env::var_os("FURU_PODCAST_RENDER_FIXTURE").is_some() {
|
||||
std::fs::write("target/podcast-player-fixture.html", html).unwrap();
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires FURU_PODCAST_TEST_DATABASE_URL pointing to a disposable PostgreSQL database"]
|
||||
async fn postgres_multiuser_progress_retention_and_admin() {
|
||||
let url = std::env::var("FURU_PODCAST_TEST_DATABASE_URL").expect("disposable database URL");
|
||||
let admin_pool = PgPool::connect(&url).await.unwrap();
|
||||
let schema = format!("podcast_test_{}", uuid::Uuid::new_v4().simple());
|
||||
sqlx::query(&format!("CREATE SCHEMA {schema}"))
|
||||
.execute(&admin_pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let search_path = format!("SET search_path TO {schema}");
|
||||
let pool = sqlx::postgres::PgPoolOptions::new()
|
||||
.max_connections(8)
|
||||
.after_connect(move |connection, _| {
|
||||
let query = search_path.clone();
|
||||
Box::pin(async move {
|
||||
sqlx::query(&query).execute(connection).await?;
|
||||
Ok(())
|
||||
})
|
||||
})
|
||||
.connect(&url)
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query("CREATE TABLE furumusic__user(id BIGINT PRIMARY KEY)")
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
for statement in include_str!("schema.sql")
|
||||
.split(';')
|
||||
.filter(|s| !s.trim().is_empty())
|
||||
{
|
||||
sqlx::query(statement).execute(&pool).await.unwrap();
|
||||
}
|
||||
// Repeatability matters for partially applied upgrades.
|
||||
for statement in include_str!("schema.sql")
|
||||
.split(';')
|
||||
.filter(|s| !s.trim().is_empty())
|
||||
{
|
||||
sqlx::query(statement).execute(&pool).await.unwrap();
|
||||
}
|
||||
sqlx::query("INSERT INTO furumusic__user VALUES(1),(2)")
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let origin = FeedUrl::parse("https://example.test/feed.xml").unwrap();
|
||||
let podcast = PodcastId::from_feed_url(&origin);
|
||||
let feed=parse_feed_with_base(br#"<rss><channel><title>Fixture</title><item><title>Episode</title><guid>one</guid><enclosure url="https://example.test/audio.mp3"/></item></channel></rss>"#,Some(origin.as_str())).unwrap();
|
||||
let episode = feed.episodes[0].to_meta(
|
||||
&podcast,
|
||||
feed.resolve_episode_ids(&podcast, &[])[0].clone().unwrap(),
|
||||
);
|
||||
if std::env::var_os("FURU_PODCAST_RENDER_FIXTURE").is_some() {
|
||||
std::fs::write("target/podcast-feed-fixture.json",json!({"id":podcast,"metadata":feed.to_podcast_meta(origin.clone()),"episode":episode,"cache_name":blake3::hash(episode.episode_id.as_str().as_bytes()).to_hex().to_string()}).to_string()).unwrap();
|
||||
}
|
||||
sqlx::query(
|
||||
"INSERT INTO furumusic__podcast(id,origin_url,feed_url,metadata) VALUES($1,$2,$2,$3)",
|
||||
)
|
||||
.bind(podcast.as_str())
|
||||
.bind(origin.as_str())
|
||||
.bind(json!(feed.to_podcast_meta(origin.clone())))
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
sqlx::query("INSERT INTO furumusic__podcast_subscription(user_id,podcast_id,shared) VALUES(1,$1,true),(2,$1,false)").bind(podcast.as_str()).execute(&pool).await.unwrap();
|
||||
sqlx::query("INSERT INTO furumusic__podcast_episode(id,podcast_id,metadata) VALUES($1,$2,$3)")
|
||||
.bind(episode.episode_id.as_str())
|
||||
.bind(podcast.as_str())
|
||||
.bind(json!(episode))
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let directory =
|
||||
std::env::temp_dir().join(format!("furumusic-podcast-test-{}", uuid::Uuid::new_v4()));
|
||||
let config = AppConfig {
|
||||
agent_storage_dir: directory.to_string_lossy().into_owned(),
|
||||
..AppConfig::default()
|
||||
};
|
||||
let media = cache_path(&config, episode.episode_id.as_str());
|
||||
tokio::fs::create_dir_all(media.parent().unwrap())
|
||||
.await
|
||||
.unwrap();
|
||||
tokio::fs::write(&media, b"saved episode").await.unwrap();
|
||||
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now()")
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
let range_request = Request::builder()
|
||||
.header("range", "bytes=0-4")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let response = super::media(
|
||||
&pool,
|
||||
&config,
|
||||
2,
|
||||
episode.episode_id.as_str(),
|
||||
&range_request,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(response.status(), StatusCode::PARTIAL_CONTENT);
|
||||
assert_eq!(response.headers()["content-range"], "bytes 0-4/13");
|
||||
assert_eq!(
|
||||
response.into_body().into_bytes().await.unwrap().as_ref(),
|
||||
b"saved"
|
||||
);
|
||||
let invalid_request = Request::builder()
|
||||
.header("range", "bytes=900-1000")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
super::media(
|
||||
&pool,
|
||||
&config,
|
||||
2,
|
||||
episode.episode_id.as_str(),
|
||||
&invalid_request
|
||||
)
|
||||
.await
|
||||
.unwrap()
|
||||
.status(),
|
||||
StatusCode::RANGE_NOT_SATISFIABLE
|
||||
);
|
||||
assert!(
|
||||
super::media(
|
||||
&pool,
|
||||
&config,
|
||||
99,
|
||||
episode.episode_id.as_str(),
|
||||
&range_request
|
||||
)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
assert_eq!(
|
||||
list(&pool, 2, false).await.unwrap()["public"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.len(),
|
||||
1
|
||||
);
|
||||
let request = |value| serde_json::from_value::<Action>(value).unwrap();
|
||||
action(
|
||||
pool.clone(),
|
||||
config.clone(),
|
||||
1,
|
||||
false,
|
||||
request(json!({"action":"remove","id":podcast})),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
list(&pool, 2, false).await.unwrap()["mine"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.len(),
|
||||
1
|
||||
);
|
||||
assert!(tokio::fs::try_exists(&media).await.unwrap());
|
||||
let first = action(
|
||||
pool.clone(),
|
||||
config.clone(),
|
||||
2,
|
||||
false,
|
||||
request(
|
||||
json!({"action":"progress","id":episode.episode_id,"explicit":true,"position_ms":5000}),
|
||||
),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let second = action(
|
||||
pool.clone(),
|
||||
config.clone(),
|
||||
2,
|
||||
false,
|
||||
request(
|
||||
json!({"action":"progress","id":episode.episode_id,"explicit":true,"position_ms":0}),
|
||||
),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
second["generation"].as_i64().unwrap(),
|
||||
first["generation"].as_i64().unwrap() + 1
|
||||
);
|
||||
action(pool.clone(),config.clone(),2,false,request(json!({"action":"progress","id":episode.episode_id,"generation":first["generation"],"sequence":999,"position_ms":99999}))).await.unwrap();
|
||||
let position: i64 = sqlx::query_scalar("SELECT position_ms FROM furumusic__podcast_progress")
|
||||
.fetch_one(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(position, 0);
|
||||
assert!(
|
||||
action(
|
||||
pool.clone(),
|
||||
config.clone(),
|
||||
2,
|
||||
false,
|
||||
request(json!({"action":"admin_settings","retention_days":7}))
|
||||
)
|
||||
.await
|
||||
.is_err()
|
||||
);
|
||||
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=now()-interval '20 days'")
|
||||
.execute(&pool)
|
||||
.await
|
||||
.unwrap();
|
||||
crate::podcasts::cleanup(&pool, &config).await.unwrap();
|
||||
assert!(tokio::fs::try_exists(&media).await.unwrap());
|
||||
action(
|
||||
pool.clone(),
|
||||
config.clone(),
|
||||
1,
|
||||
true,
|
||||
request(json!({"action":"admin_settings","retention_days":7})),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
crate::podcasts::cleanup(&pool, &config).await.unwrap();
|
||||
assert!(!tokio::fs::try_exists(&media).await.unwrap());
|
||||
let state: (bool,i64)=sqlx::query_as("SELECT expired,(SELECT count(*) FROM furumusic__podcast_progress) FROM furumusic__podcast_episode").fetch_one(&pool).await.unwrap();
|
||||
assert_eq!(state, (true, 1));
|
||||
action(
|
||||
pool.clone(),
|
||||
config.clone(),
|
||||
1,
|
||||
true,
|
||||
request(json!({"action":"admin_delete","id":podcast})),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(
|
||||
list(&pool, 2, false).await.unwrap()["mine"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.is_empty()
|
||||
);
|
||||
pool.close().await;
|
||||
sqlx::query(&format!("DROP SCHEMA {schema} CASCADE"))
|
||||
.execute(&admin_pool)
|
||||
.await
|
||||
.unwrap();
|
||||
tokio::fs::remove_dir_all(&directory).await.unwrap();
|
||||
}
|
||||
@@ -0,0 +1,427 @@
|
||||
use super::*;
|
||||
use crate::{auth, auth::Role};
|
||||
use cot::http::{Request, StatusCode};
|
||||
use cot::{
|
||||
App, Body,
|
||||
db::Database,
|
||||
json::Json,
|
||||
request::extractors::Path,
|
||||
response::IntoResponse,
|
||||
router::{
|
||||
Route, Router,
|
||||
method::{get, post},
|
||||
},
|
||||
session::Session,
|
||||
};
|
||||
use futures_util::TryStreamExt;
|
||||
use serde::Deserialize;
|
||||
use std::sync::Arc;
|
||||
|
||||
#[cfg(test)]
|
||||
#[path = "tests.rs"]
|
||||
mod tests;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Action {
|
||||
action: String,
|
||||
#[serde(default)]
|
||||
id: String,
|
||||
#[serde(default)]
|
||||
url: String,
|
||||
#[serde(default)]
|
||||
query: String,
|
||||
#[serde(default)]
|
||||
shared: bool,
|
||||
#[serde(default)]
|
||||
confirmed: bool,
|
||||
#[serde(default)]
|
||||
position_ms: i64,
|
||||
#[serde(default)]
|
||||
completed: bool,
|
||||
#[serde(default)]
|
||||
explicit: bool,
|
||||
#[serde(default)]
|
||||
generation: i64,
|
||||
#[serde(default)]
|
||||
sequence: i64,
|
||||
#[serde(default)]
|
||||
offset: i64,
|
||||
retention_days: Option<i32>,
|
||||
}
|
||||
#[derive(Deserialize)]
|
||||
struct EpisodePath {
|
||||
id: String,
|
||||
}
|
||||
|
||||
fn episode_path_id(value: &str) -> Result<music_dht::podcast::EpisodeId> {
|
||||
// Cot's path extractor preserves percent escapes. The contract's only
|
||||
// escaped path character is the colon separating the id prefix.
|
||||
let decoded = value.replace("%3A", ":").replace("%3a", ":");
|
||||
Ok(serde_json::from_value(json!(decoded))?)
|
||||
}
|
||||
|
||||
fn error(status: StatusCode, message: &str) -> cot::Result<cot::response::Response> {
|
||||
Ok(cot::http::Response::builder()
|
||||
.status(status)
|
||||
.header("Content-Type", "application/json")
|
||||
.body(Body::fixed(json!({"error":message}).to_string()))
|
||||
.expect("valid response"))
|
||||
}
|
||||
|
||||
async fn list(pool: &PgPool, user: i64, admin: bool) -> Result<Value> {
|
||||
let mine: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'metadata',p.metadata,'shared',s.shared,'checked_at',p.checked_at,'error',p.last_error,'episodes',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id),'new_episodes',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id AND NOT EXISTS(SELECT 1 FROM furumusic__podcast_progress g WHERE g.user_id=$1 AND g.episode_id=e.id AND g.completed))) FROM furumusic__podcast p JOIN furumusic__podcast_subscription s ON s.podcast_id=p.id WHERE s.user_id=$1 ORDER BY p.metadata->>'title'").bind(user).fetch_all(pool).await?;
|
||||
let public: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'url',p.origin_url,'metadata',p.metadata,'subscribed',EXISTS(SELECT 1 FROM furumusic__podcast_subscription m WHERE m.user_id=$1 AND m.podcast_id=p.id)) FROM furumusic__podcast p WHERE EXISTS(SELECT 1 FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND s.shared AND s.user_id<>$1) ORDER BY p.metadata->>'title' LIMIT 200").bind(user).fetch_all(pool).await?;
|
||||
let mut result = json!({"mine":mine,"public":public});
|
||||
if admin {
|
||||
let all: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',p.id,'metadata',p.metadata,'error',p.last_error,'checked_at',p.checked_at,'subscribers',(SELECT count(*) FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id),'public',(SELECT count(*) FROM furumusic__podcast_subscription s WHERE s.podcast_id=p.id AND s.shared),'cached',(SELECT count(*) FROM furumusic__podcast_episode e WHERE e.podcast_id=p.id AND cached_at IS NOT NULL)) FROM furumusic__podcast p ORDER BY p.metadata->>'title'").fetch_all(pool).await?;
|
||||
let days: Option<i32> =
|
||||
sqlx::query_scalar("SELECT retention_days FROM furumusic__podcast_settings WHERE id=1")
|
||||
.fetch_one(pool)
|
||||
.await?;
|
||||
result["all"] = json!(all);
|
||||
result["retention_days"] = json!(days);
|
||||
}
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
async fn require_subscription(pool: &PgPool, user: i64, id: &str) -> Result<()> {
|
||||
let yes: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2)").bind(user).bind(id).fetch_one(pool).await?;
|
||||
if !yes {
|
||||
bail!("podcast subscription not found");
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn action(
|
||||
pool: PgPool,
|
||||
config: AppConfig,
|
||||
user: i64,
|
||||
admin: bool,
|
||||
body: Action,
|
||||
) -> Result<Value> {
|
||||
if body.action.starts_with("admin_") && !admin {
|
||||
bail!("administrator access required");
|
||||
}
|
||||
match body.action.as_str() {
|
||||
"list" => return list(&pool, user, false).await,
|
||||
"admin_list" => return list(&pool, user, true).await,
|
||||
"add" => {
|
||||
let id = subscribe(&pool, user, &body.url).await?;
|
||||
let checked = refresh(&pool, &id).await;
|
||||
tokio::spawn(async move {
|
||||
let _ = download_pending(&pool, &config, Some(&id)).await;
|
||||
});
|
||||
return Ok(
|
||||
json!({"ok":true,"warning":checked.err().map(|_| "Feed check failed; the subscription was saved") }),
|
||||
);
|
||||
}
|
||||
"remove" => {
|
||||
sqlx::query(
|
||||
"DELETE FROM furumusic__podcast_subscription WHERE user_id=$1 AND podcast_id=$2",
|
||||
)
|
||||
.bind(user)
|
||||
.bind(&body.id)
|
||||
.execute(&pool)
|
||||
.await?;
|
||||
}
|
||||
"share" => {
|
||||
require_subscription(&pool, user, &body.id).await?;
|
||||
let row = sqlx::query("SELECT origin_url,metadata FROM furumusic__podcast WHERE id=$1")
|
||||
.bind(&body.id)
|
||||
.fetch_one(&pool)
|
||||
.await?;
|
||||
let meta: PodcastMeta = serde_json::from_value(row.get("metadata"))?;
|
||||
let origin = FeedUrl::parse(row.get::<&str, _>("origin_url"))?;
|
||||
let sub = SubscriptionRecord {
|
||||
podcast_id: serde_json::from_value(json!(body.id))?,
|
||||
subscribed: true,
|
||||
podcast: meta,
|
||||
feed_aliases: vec![origin],
|
||||
generation: 1,
|
||||
hlc_ms: 1,
|
||||
op_id: "web".into(),
|
||||
};
|
||||
let card = PodcastCardSpec::from_subscription(&sub)?;
|
||||
let urls = json!([card.feed_url, card.id_feed_url]);
|
||||
if body.shared && !body.confirmed && !card.privacy_warnings().is_empty() {
|
||||
return Ok(json!({"confirmation_required":true,"urls":urls}));
|
||||
}
|
||||
sqlx::query("UPDATE furumusic__podcast_subscription SET shared=$3,confirmed_urls=$4 WHERE user_id=$1 AND podcast_id=$2").bind(user).bind(&body.id).bind(body.shared).bind(if body.shared {Some(urls)} else {None}).execute(&pool).await?;
|
||||
}
|
||||
"episodes" => {
|
||||
require_subscription(&pool, user, &body.id).await?;
|
||||
let mut episodes: Vec<Value> = sqlx::query_scalar("SELECT jsonb_build_object('id',e.id,'metadata',e.metadata,'cached',e.cached_at IS NOT NULL,'downloading',COALESCE(e.download_until>now(),false),'error',e.download_error,'position_ms',COALESCE(g.position_ms,0),'completed',COALESCE(g.completed,false)) FROM furumusic__podcast_episode e LEFT JOIN furumusic__podcast_progress g ON g.episode_id=e.id AND g.user_id=$1 WHERE e.podcast_id=$2 ORDER BY (e.metadata->>'published_at_ms')::bigint DESC NULLS LAST,e.discovered_at DESC,e.id LIMIT 201 OFFSET $3").bind(user).bind(&body.id).bind(body.offset.max(0)).fetch_all(&pool).await?;
|
||||
let more = episodes.len() > 200;
|
||||
episodes.truncate(200);
|
||||
return Ok(json!({"episodes":episodes,"has_more":more}));
|
||||
}
|
||||
"refresh" | "admin_refresh" => {
|
||||
if body.action == "refresh" {
|
||||
require_subscription(&pool, user, &body.id).await?;
|
||||
}
|
||||
let added = refresh(&pool, &body.id).await?;
|
||||
tokio::spawn(async move {
|
||||
let _ = download_pending(&pool, &config, Some(&body.id)).await;
|
||||
});
|
||||
return Ok(json!({"added":added}));
|
||||
}
|
||||
"download" | "progress" => {
|
||||
let podcast: String =
|
||||
sqlx::query_scalar("SELECT podcast_id FROM furumusic__podcast_episode WHERE id=$1")
|
||||
.bind(&body.id)
|
||||
.fetch_one(&pool)
|
||||
.await?;
|
||||
require_subscription(&pool, user, &podcast).await?;
|
||||
if body.action == "download" {
|
||||
tokio::spawn(async move {
|
||||
let _ = download(&pool, &config, &body.id, true).await;
|
||||
});
|
||||
return Ok(json!({"ok":true}));
|
||||
}
|
||||
let duration: Option<i64> = sqlx::query_scalar("SELECT (metadata->>'duration_ms')::bigint FROM furumusic__podcast_episode WHERE id=$1").bind(&body.id).fetch_one(&pool).await?;
|
||||
let completed = body.completed
|
||||
|| (!body.explicit
|
||||
&& music_dht::podcast::reaches_completion(body.position_ms, duration));
|
||||
let generation: Option<i64> = if body.explicit {
|
||||
Some(sqlx::query_scalar("INSERT INTO furumusic__podcast_progress(user_id,episode_id,position_ms,completed,generation,checkpoint) VALUES($1,$2,$3,$4,1,$5) ON CONFLICT(user_id,episode_id) DO UPDATE SET position_ms=EXCLUDED.position_ms,completed=EXCLUDED.completed,generation=furumusic__podcast_progress.generation+1,checkpoint=EXCLUDED.checkpoint,updated_at=now() RETURNING generation").bind(user).bind(&body.id).bind(body.position_ms.max(0)).bind(completed).bind(body.sequence).fetch_one(&pool).await?)
|
||||
} else {
|
||||
sqlx::query_scalar("UPDATE furumusic__podcast_progress SET position_ms=$3,completed=$4,checkpoint=$6,updated_at=now() WHERE user_id=$1 AND episode_id=$2 AND generation=$5 AND checkpoint<=$6 RETURNING generation").bind(user).bind(&body.id).bind(body.position_ms.max(0)).bind(completed).bind(body.generation).bind(body.sequence).fetch_optional(&pool).await?
|
||||
};
|
||||
return Ok(json!({"ok":true,"generation":generation}));
|
||||
}
|
||||
"search" => {
|
||||
if body.query.chars().count() < 2 || body.query.len() > 200 {
|
||||
bail!("enter 2–200 characters");
|
||||
}
|
||||
let hits = crate::federation::handle()
|
||||
.search_podcasts(&body.query)
|
||||
.await?;
|
||||
return Ok(json!({"hits":hits}));
|
||||
}
|
||||
"admin_settings" => {
|
||||
if body
|
||||
.retention_days
|
||||
.is_some_and(|days| !(1..=36500).contains(&days))
|
||||
{
|
||||
bail!("retention must be between 1 and 36500 days");
|
||||
}
|
||||
sqlx::query("UPDATE furumusic__podcast_settings SET retention_days=$1 WHERE id=1")
|
||||
.bind(body.retention_days)
|
||||
.execute(&pool)
|
||||
.await?;
|
||||
}
|
||||
"admin_unpublish" => {
|
||||
sqlx::query("UPDATE furumusic__podcast_subscription SET shared=false,confirmed_urls=NULL WHERE podcast_id=$1").bind(&body.id).execute(&pool).await?;
|
||||
}
|
||||
"admin_clear" | "admin_delete" => {
|
||||
let mut tx = pool.begin().await?;
|
||||
let locked: bool =
|
||||
sqlx::query_scalar("SELECT pg_try_advisory_xact_lock(hashtextextended($1,7421))")
|
||||
.bind(&body.id)
|
||||
.fetch_one(&mut *tx)
|
||||
.await?;
|
||||
if !locked {
|
||||
bail!("downloads are running; try again when they finish");
|
||||
}
|
||||
sqlx::query("SELECT id FROM furumusic__podcast WHERE id=$1 FOR UPDATE")
|
||||
.bind(&body.id)
|
||||
.fetch_optional(&mut *tx)
|
||||
.await?;
|
||||
let ids: Vec<String> =
|
||||
sqlx::query_scalar("SELECT id FROM furumusic__podcast_episode WHERE podcast_id=$1")
|
||||
.bind(&body.id)
|
||||
.fetch_all(&pool)
|
||||
.await?;
|
||||
// A leased download must finish before clearing or deleting its catalogue.
|
||||
let busy: bool = sqlx::query_scalar("SELECT EXISTS(SELECT 1 FROM furumusic__podcast_episode WHERE podcast_id=$1 AND download_until>now())").bind(&body.id).fetch_one(&pool).await?;
|
||||
if busy {
|
||||
bail!("downloads are running; try again when they finish");
|
||||
}
|
||||
for id in ids {
|
||||
match tokio::fs::remove_file(cache_path(&config, &id)).await {
|
||||
Ok(()) => {}
|
||||
Err(e) if e.kind() == std::io::ErrorKind::NotFound => {}
|
||||
Err(e) => return Err(e.into()),
|
||||
}
|
||||
}
|
||||
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=NULL,expired=true WHERE podcast_id=$1").bind(&body.id).execute(&mut *tx).await?;
|
||||
if body.action == "admin_delete" {
|
||||
sqlx::query("DELETE FROM furumusic__podcast WHERE id=$1")
|
||||
.bind(&body.id)
|
||||
.execute(&mut *tx)
|
||||
.await?;
|
||||
}
|
||||
tx.commit().await?;
|
||||
}
|
||||
_ => bail!("unknown podcast action"),
|
||||
}
|
||||
let federation = crate::federation::handle();
|
||||
let pending = federation.sync_podcasts().await.is_err();
|
||||
Ok(json!({"ok":true,"publication_pending":pending}))
|
||||
}
|
||||
|
||||
async fn media(
|
||||
pool: &PgPool,
|
||||
config: &AppConfig,
|
||||
user: i64,
|
||||
id: &str,
|
||||
request: &Request<Body>,
|
||||
) -> Result<cot::response::Response> {
|
||||
let row = sqlx::query("SELECT e.metadata,e.cached_at IS NOT NULL AS cached FROM furumusic__podcast_episode e JOIN furumusic__podcast_subscription s ON s.podcast_id=e.podcast_id WHERE e.id=$1 AND s.user_id=$2").bind(id).bind(user).fetch_one(pool).await?;
|
||||
let meta: EpisodeMeta = serde_json::from_value(row.get("metadata"))?;
|
||||
let range = request.headers().get("range").and_then(|v| v.to_str().ok());
|
||||
let mut builder = cot::http::Response::builder().header("Cache-Control", "private, no-store");
|
||||
let path = cache_path(config, id);
|
||||
if row.get::<bool, _>("cached") && tokio::fs::try_exists(&path).await? {
|
||||
use tokio::io::{AsyncReadExt, AsyncSeekExt};
|
||||
let mut file = tokio::fs::File::open(&path).await?;
|
||||
let size = file.metadata().await?.len();
|
||||
let (start, end) = if let Some(range) = range {
|
||||
match crate::player::parse_range(range, size) {
|
||||
Some((start, end)) => {
|
||||
builder = builder
|
||||
.status(206)
|
||||
.header("Content-Range", format!("bytes {start}-{end}/{size}"));
|
||||
(start, end)
|
||||
}
|
||||
None => {
|
||||
return Ok(builder
|
||||
.status(416)
|
||||
.header("Content-Range", format!("bytes */{size}"))
|
||||
.body(Body::empty())?);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
(0, size.saturating_sub(1))
|
||||
};
|
||||
file.seek(std::io::SeekFrom::Start(start)).await?;
|
||||
let stream = tokio_util::io::ReaderStream::new(file.take(end - start + 1))
|
||||
.map_err(|e| cot::Error::internal(e.to_string()));
|
||||
return Ok(builder
|
||||
.header("Content-Type", meta.mime.as_deref().unwrap_or("audio/mpeg"))
|
||||
.header("Accept-Ranges", "bytes")
|
||||
.header("Content-Length", (end - start + 1).to_string())
|
||||
.body(Body::streaming(stream))?);
|
||||
}
|
||||
sqlx::query("UPDATE furumusic__podcast_episode SET cached_at=NULL WHERE id=$1")
|
||||
.bind(id)
|
||||
.execute(pool)
|
||||
.await?;
|
||||
let pool_clone = pool.clone();
|
||||
let config_clone = config.clone();
|
||||
let id_clone = id.to_owned();
|
||||
tokio::spawn(async move {
|
||||
let _ = download(&pool_clone, &config_clone, &id_clone, true).await;
|
||||
});
|
||||
let response = fetch(&meta.audio_url, range, None).await?;
|
||||
builder = builder.status(response.status());
|
||||
for key in [
|
||||
"content-type",
|
||||
"content-length",
|
||||
"content-range",
|
||||
"accept-ranges",
|
||||
] {
|
||||
if let Some(value) = response.headers().get(key) {
|
||||
builder = builder.header(key, value);
|
||||
}
|
||||
}
|
||||
let stream = response
|
||||
.bytes_stream()
|
||||
.map_err(|_| cot::Error::internal("podcast stream interrupted"));
|
||||
Ok(builder.body(Body::streaming(stream))?)
|
||||
}
|
||||
|
||||
pub struct PodcastApp {
|
||||
config: Arc<AppConfig>,
|
||||
}
|
||||
impl PodcastApp {
|
||||
pub fn new(config: Arc<AppConfig>) -> Self {
|
||||
Self { config }
|
||||
}
|
||||
}
|
||||
impl App for PodcastApp {
|
||||
fn name(&self) -> &'static str {
|
||||
"podcasts"
|
||||
}
|
||||
fn router(&self) -> Router {
|
||||
let pool = sqlx::postgres::PgPoolOptions::new()
|
||||
.max_connections(8)
|
||||
.connect_lazy(&self.config.database_url)
|
||||
.expect("podcast pool configuration");
|
||||
let action_pool = pool.clone();
|
||||
Router::with_urls([
|
||||
Route::with_handler_and_name(
|
||||
"/action",
|
||||
{
|
||||
post(
|
||||
move |auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
Json(body): Json<Action>| {
|
||||
let pool = action_pool.clone();
|
||||
async move {
|
||||
let Some(user) =
|
||||
auth::get_request_user(&auth_ctx, &session, &db).await
|
||||
else {
|
||||
return error(StatusCode::UNAUTHORIZED, "not authenticated");
|
||||
};
|
||||
if body.action.starts_with("admin_") && user.role != Role::Admin {
|
||||
return error(
|
||||
StatusCode::FORBIDDEN,
|
||||
"administrator access required",
|
||||
);
|
||||
}
|
||||
let (config, _) = AppConfig::load_with_db(&db).await;
|
||||
match action(pool, config, user.id, user.role == Role::Admin, body)
|
||||
.await
|
||||
{
|
||||
Ok(value) => Json(value).into_response(),
|
||||
Err(err) => {
|
||||
let message = if err.downcast_ref::<sqlx::Error>().is_some()
|
||||
{
|
||||
"Podcast storage operation failed; try again".to_owned()
|
||||
} else {
|
||||
err.to_string()
|
||||
};
|
||||
error(StatusCode::BAD_REQUEST, &message)
|
||||
}
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
"podcast_action",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/media/{id}",
|
||||
{
|
||||
get(
|
||||
move |auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
path: Path<EpisodePath>,
|
||||
request: Request<Body>| {
|
||||
let pool = pool.clone();
|
||||
async move {
|
||||
let Some(user) =
|
||||
auth::get_request_user(&auth_ctx, &session, &db).await
|
||||
else {
|
||||
return error(StatusCode::UNAUTHORIZED, "not authenticated");
|
||||
};
|
||||
let (config, _) = AppConfig::load_with_db(&db).await;
|
||||
let Ok(id) = episode_path_id(&path.0.id) else {
|
||||
return error(StatusCode::NOT_FOUND, "episode unavailable");
|
||||
};
|
||||
match media(&pool, &config, user.id, id.as_str(), &request).await {
|
||||
Ok(response) => Ok(response),
|
||||
Err(_) => error(StatusCode::NOT_FOUND, "episode unavailable"),
|
||||
}
|
||||
}
|
||||
},
|
||||
)
|
||||
},
|
||||
"podcast_media",
|
||||
),
|
||||
])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
<section
|
||||
class="panel settings-section"
|
||||
id="settings-podcasts"
|
||||
x-data="podcastAdmin()"
|
||||
x-effect="if(activeView!=='settings')visible=false"
|
||||
>
|
||||
<div class="panel-head">
|
||||
<div class="panel-title">
|
||||
<strong>Podcasts</strong><span>Shared catalogue, publications and audio retention</span>
|
||||
</div>
|
||||
<button type="button" class="btn" @click="open()">Manage podcasts</button>
|
||||
</div>
|
||||
<div
|
||||
class="modal-backdrop"
|
||||
x-show="visible"
|
||||
x-cloak
|
||||
x-effect="adminOverlay.sync($el, visible)"
|
||||
@keydown="adminOverlay.keydown($event, $el)"
|
||||
@keydown.escape.window="visible=false"
|
||||
@click.self="visible=false"
|
||||
>
|
||||
<section
|
||||
class="modal"
|
||||
role="dialog"
|
||||
aria-modal="true"
|
||||
aria-labelledby="podcast-admin-title"
|
||||
tabindex="-1"
|
||||
style="width:min(1000px,95vw);max-height:90vh;overflow:auto"
|
||||
>
|
||||
<header class="modal-head">
|
||||
<h2 id="podcast-admin-title">Instance podcasts</h2>
|
||||
<button
|
||||
class="btn"
|
||||
data-dialog-close
|
||||
aria-label="Close podcasts"
|
||||
@click="visible=false"
|
||||
>
|
||||
Close
|
||||
</button>
|
||||
</header>
|
||||
<div class="modal-body">
|
||||
<p>
|
||||
Shared catalogue for all users. Clearing audio keeps subscriptions and listening
|
||||
progress. Deleting a podcast removes it for every subscriber.
|
||||
</p>
|
||||
<form class="toolbar" @submit.prevent="save()">
|
||||
<label
|
||||
><input type="checkbox" x-model="retention" /> Automatically remove saved
|
||||
audio</label
|
||||
><label
|
||||
>Keep for
|
||||
<input
|
||||
class="search"
|
||||
type="number"
|
||||
min="1"
|
||||
max="36500"
|
||||
required
|
||||
x-model.number="days"
|
||||
:disabled="!retention"
|
||||
style="width:100px"
|
||||
/>
|
||||
days after download</label
|
||||
><button class="btn" :disabled="busy">Save retention</button>
|
||||
</form>
|
||||
<p class="muted">
|
||||
Disabled by default. Episode metadata remains available; expired audio can be
|
||||
saved again manually. Feed checks run in the internal “podcast_refresh”
|
||||
scheduled job.
|
||||
</p>
|
||||
<div role="status" aria-live="polite" x-text="message"></div>
|
||||
<input
|
||||
class="search"
|
||||
x-model="filter"
|
||||
placeholder="Filter podcasts"
|
||||
aria-label="Filter podcasts"
|
||||
style="margin:12px 0;width:100%"
|
||||
/>
|
||||
<p x-show="!items.length">No known podcasts.</p>
|
||||
<template
|
||||
x-for="pod in items.filter(p=>(p.metadata.title+' '+p.metadata.feed_url).toLowerCase().includes(filter.toLowerCase()))"
|
||||
:key="pod.id"
|
||||
><article
|
||||
class="panel"
|
||||
style="padding:16px;margin:12px 0;overflow-wrap:anywhere"
|
||||
>
|
||||
<h3 x-text="pod.metadata.title"></h3>
|
||||
<p x-text="pod.metadata.feed_url"></p>
|
||||
<p
|
||||
x-text="pod.subscribers+' subscribers · '+pod.public+' publications · '+pod.cached+' saved episodes'"
|
||||
></p>
|
||||
<p x-show="pod.error" x-text="pod.error"></p>
|
||||
<div class="toolbar">
|
||||
<button class="btn" :disabled="busy" @click="run('admin_refresh',pod)">
|
||||
Check episodes</button
|
||||
><button
|
||||
class="btn"
|
||||
:disabled="busy"
|
||||
@click="run('admin_unpublish',pod)"
|
||||
>
|
||||
Unpublish</button
|
||||
><button class="btn" :disabled="busy" @click="run('admin_clear',pod)">
|
||||
Clear saved audio</button
|
||||
><button
|
||||
class="btn danger"
|
||||
:disabled="busy"
|
||||
@click="run('admin_delete',pod)"
|
||||
>
|
||||
Delete for all users
|
||||
</button>
|
||||
</div>
|
||||
</article></template
|
||||
>
|
||||
</div>
|
||||
</section>
|
||||
</div>
|
||||
</section>
|
||||
<script>
|
||||
function podcastAdmin() {
|
||||
return {
|
||||
visible: false,
|
||||
busy: false,
|
||||
items: [],
|
||||
filter: '',
|
||||
retention: false,
|
||||
days: 30,
|
||||
message: '',
|
||||
async api(action, body = {}) {
|
||||
const res = await fetch('/api/podcasts/action', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ action, ...body }),
|
||||
});
|
||||
const data = await res.json();
|
||||
if (!res.ok) throw new Error(data.error || 'Podcast operation failed');
|
||||
return data;
|
||||
},
|
||||
async load() {
|
||||
const data = await this.api('admin_list');
|
||||
this.items = data.all;
|
||||
this.retention = data.retention_days !== null;
|
||||
this.days = data.retention_days || 30;
|
||||
},
|
||||
async open() {
|
||||
this.visible = true;
|
||||
this.busy = true;
|
||||
try {
|
||||
await this.load();
|
||||
this.message = '';
|
||||
} catch (e) {
|
||||
this.message = e.message;
|
||||
} finally {
|
||||
this.busy = false;
|
||||
}
|
||||
},
|
||||
async save() {
|
||||
this.busy = true;
|
||||
try {
|
||||
await this.api('admin_settings', {
|
||||
retention_days: this.retention ? Number(this.days) : null,
|
||||
});
|
||||
this.message = 'Retention settings saved';
|
||||
} catch (e) {
|
||||
this.message = e.message;
|
||||
} finally {
|
||||
this.busy = false;
|
||||
}
|
||||
},
|
||||
async run(action, pod) {
|
||||
if (
|
||||
action !== 'admin_refresh' &&
|
||||
!confirm(
|
||||
action === 'admin_delete'
|
||||
? 'Delete this podcast and ALL users’ subscriptions and progress?'
|
||||
: 'Apply this action to the shared podcast for every user?',
|
||||
)
|
||||
)
|
||||
return;
|
||||
this.busy = true;
|
||||
try {
|
||||
const result = await this.api(action, { id: pod.id });
|
||||
await this.load();
|
||||
this.message = result.publication_pending
|
||||
? 'Saved; Frid publication reconciliation is pending.'
|
||||
: 'Done';
|
||||
} catch (e) {
|
||||
this.message = e.message;
|
||||
} finally {
|
||||
this.busy = false;
|
||||
}
|
||||
},
|
||||
};
|
||||
}
|
||||
</script>
|
||||
@@ -631,9 +631,10 @@
|
||||
<div class="settings-page">
|
||||
<label class="section-jump">Settings section
|
||||
<select class="search" @change="jumpToSettings($event.target.value)">
|
||||
<option value="access">Access</option><option value="oidc">SSO</option><option value="agent">Import agent</option><option value="similarity">Similarity</option><option value="downloads">Downloads</option><option value="federation">Federation</option><option value="lastfm">Last.fm</option><option value="developer">Developer</option>
|
||||
<option value="access">Access</option><option value="oidc">SSO</option><option value="agent">Import agent</option><option value="similarity">Similarity</option><option value="downloads">Downloads</option><option value="podcasts">Podcasts</option><option value="federation">Federation</option><option value="lastfm">Last.fm</option><option value="developer">Developer</option>
|
||||
</select>
|
||||
</label>
|
||||
{% include "admin/podcasts.html" %}
|
||||
<form class="settings-layout" @submit.prevent="saveSettings()">
|
||||
<div class="settings-column">
|
||||
<section class="panel settings-section settings-section-wide settings-oidc" id="settings-oidc">
|
||||
|
||||
@@ -10,4 +10,5 @@
|
||||
{% include "player/shell.html" %}
|
||||
{% include "player/modals.html" %}
|
||||
{% include "player/scripts.html" %}
|
||||
{% include "player/podcast_scripts.html" %}
|
||||
{% endblock body %}
|
||||
@@ -0,0 +1,358 @@
|
||||
<script>
|
||||
document.addEventListener('alpine:init', () => {
|
||||
const labels = {
|
||||
podcasts: ['Podcasts', 'Подкасты'],
|
||||
add: ['Add', 'Добавить'],
|
||||
mine: ['My podcasts', 'Мои подкасты'],
|
||||
public: ['Public podcasts', 'Публичные подкасты'],
|
||||
empty: ['Add an RSS or Atom feed.', 'Добавьте RSS или Atom ленту.'],
|
||||
check: ['Check episodes', 'Проверить выпуски'],
|
||||
checkAll: ['Check all', 'Проверить все'],
|
||||
publish: ['Publish', 'Опубликовать'],
|
||||
unpublish: ['Unpublish', 'Снять публикацию'],
|
||||
remove: ['Unsubscribe', 'Отписаться'],
|
||||
subscribe: ['Subscribe', 'Подписаться'],
|
||||
play: ['Play', 'Слушать'],
|
||||
resume: ['Resume', 'Продолжить'],
|
||||
download: ['Save on server', 'Сохранить на сервере'],
|
||||
saved: ['Saved on server', 'Сохранено на сервере'],
|
||||
downloading: ['Downloading…', 'Скачивается…'],
|
||||
markPlayed: ['Mark played', 'Прослушано'],
|
||||
markUnplayed: ['Mark unplayed', 'Не прослушано'],
|
||||
restart: ['Start over', 'С начала'],
|
||||
filter: ['Filter episodes', 'Поиск выпусков'],
|
||||
season: ['Season', 'Сезон'],
|
||||
allSeasons: ['All seasons', 'Все сезоны'],
|
||||
unplayed: ['unplayed', 'не прослушано'],
|
||||
unplayedOnly: ['Unplayed only', 'Только непрослушанные'],
|
||||
description: ['Description', 'Описание'],
|
||||
noEpisodes: ['No episodes in this filter.', 'В этом фильтре нет выпусков.'],
|
||||
noPublic: ['No public podcasts yet.', 'Публичных подкастов пока нет.'],
|
||||
searchNetwork: ['Search Frid podcasts', 'Поиск подкастов в Frid'],
|
||||
search: ['Search', 'Найти'],
|
||||
working: ['Working…', 'Выполняется…'],
|
||||
done: ['Done', 'Готово'],
|
||||
removeConfirm: [
|
||||
'Remove only your subscription? Other subscribers keep access.',
|
||||
'Удалить только вашу подписку? Доступ других подписчиков сохранится.',
|
||||
],
|
||||
shareConfirm: [
|
||||
'Publish this feed URL to other users and Frid?',
|
||||
'Опубликовать ссылку на ленту для других пользователей и Frid?',
|
||||
],
|
||||
privateConfirm: [
|
||||
'This URL may contain private access credentials. Publish these exact URLs?',
|
||||
'Ссылка может содержать приватный токен доступа. Опубликовать именно эти ссылки?',
|
||||
],
|
||||
pending: [
|
||||
'Saved. Frid publication will retry when federation is available.',
|
||||
'Сохранено. Публикация в Frid повторится, когда федерация будет доступна.',
|
||||
],
|
||||
checked: ['New episodes: ', 'Новых выпусков: '],
|
||||
failed: [
|
||||
'Operation failed. Please try again.',
|
||||
'Не удалось выполнить действие. Повторите попытку.',
|
||||
],
|
||||
};
|
||||
Alpine.store('podcasts', {
|
||||
mine: [],
|
||||
public: [],
|
||||
hits: [],
|
||||
episodes: [],
|
||||
hasMore: false,
|
||||
selected: null,
|
||||
url: '',
|
||||
query: '',
|
||||
filter: '',
|
||||
season: '',
|
||||
unplayedOnly: false,
|
||||
busy: false,
|
||||
message: '',
|
||||
poller: null,
|
||||
lastCheckpoint: 0,
|
||||
text(key) {
|
||||
if (key === 'loadMore')
|
||||
return document.documentElement.lang.startsWith('ru')
|
||||
? 'Загрузить ещё выпуски'
|
||||
: 'Load more episodes';
|
||||
return labels[key]?.[document.documentElement.lang.startsWith('ru') ? 1 : 0] || key;
|
||||
},
|
||||
async api(action, body = {}) {
|
||||
const res = await fetch('/api/podcasts/action', {
|
||||
method: 'POST',
|
||||
headers: { 'Content-Type': 'application/json' },
|
||||
body: JSON.stringify({ action, ...body }),
|
||||
});
|
||||
const data = await res.json();
|
||||
if (!res.ok) throw new Error(data.error || this.text('failed'));
|
||||
return data;
|
||||
},
|
||||
async task(fn) {
|
||||
if (this.busy) return;
|
||||
this.busy = true;
|
||||
this.message = this.text('working');
|
||||
try {
|
||||
await fn();
|
||||
} catch (e) {
|
||||
this.message = e.message || this.text('failed');
|
||||
} finally {
|
||||
this.busy = false;
|
||||
}
|
||||
},
|
||||
async load() {
|
||||
const data = await this.api('list');
|
||||
this.mine = data.mine;
|
||||
this.public = data.public;
|
||||
},
|
||||
enter() {
|
||||
Alpine.store('library').view = 'podcasts';
|
||||
Alpine.store('mobile')?.closeLibrary();
|
||||
this.task(async () => {
|
||||
await this.load();
|
||||
this.message = '';
|
||||
});
|
||||
if (!this.poller)
|
||||
this.poller = setInterval(() => {
|
||||
if (Alpine.store('library').view === 'podcasts' && !this.busy)
|
||||
this.update().catch(() => {});
|
||||
}, 5000);
|
||||
},
|
||||
async update() {
|
||||
await this.load();
|
||||
if (this.selected && !this.mine.some((p) => p.id === this.selected.id)) {
|
||||
this.selected = null;
|
||||
this.episodes = [];
|
||||
}
|
||||
if (this.selected) await this.loadEpisodes();
|
||||
},
|
||||
async loadEpisodes(append = false) {
|
||||
const id = this.selected.id;
|
||||
const offset = append ? this.episodes.length : 0;
|
||||
const data = await this.api('episodes', { id, offset });
|
||||
if (this.selected?.id !== id) return;
|
||||
const old = this.episodes;
|
||||
this.episodes = append
|
||||
? [...old, ...data.episodes]
|
||||
: [
|
||||
...new Map(
|
||||
[...data.episodes, ...old].map((e) => [e.id, e]),
|
||||
).values(),
|
||||
];
|
||||
if (append || old.length <= 200) this.hasMore = !!data.has_more;
|
||||
},
|
||||
more() {
|
||||
return this.task(async () => {
|
||||
await this.loadEpisodes(true);
|
||||
this.message = '';
|
||||
});
|
||||
},
|
||||
open(pod) {
|
||||
this.selected = pod;
|
||||
this.episodes = [];
|
||||
this.hasMore = false;
|
||||
this.filter = '';
|
||||
this.season = '';
|
||||
this.task(async () => {
|
||||
await this.loadEpisodes();
|
||||
this.message = '';
|
||||
});
|
||||
},
|
||||
add(url) {
|
||||
this.task(async () => {
|
||||
const result = await this.api('add', { url: url || this.url });
|
||||
this.url = '';
|
||||
await this.load();
|
||||
this.message = result.warning || this.text('done');
|
||||
});
|
||||
},
|
||||
remove(pod) {
|
||||
if (!confirm(this.text('removeConfirm'))) return;
|
||||
this.task(async () => {
|
||||
const result = await this.api('remove', { id: pod.id });
|
||||
if (this.selected?.id === pod.id) {
|
||||
this.selected = null;
|
||||
this.episodes = [];
|
||||
}
|
||||
await this.load();
|
||||
this.message = this.text(result.publication_pending ? 'pending' : 'done');
|
||||
});
|
||||
},
|
||||
share(pod) {
|
||||
if (
|
||||
!pod.shared &&
|
||||
!confirm(this.text('shareConfirm') + '\n' + pod.metadata.feed_url)
|
||||
)
|
||||
return;
|
||||
this.task(async () => {
|
||||
let result = await this.api('share', { id: pod.id, shared: !pod.shared });
|
||||
if (result.confirmation_required) {
|
||||
if (
|
||||
!confirm(
|
||||
this.text('privateConfirm') +
|
||||
'\n' +
|
||||
result.urls.filter(Boolean).join('\n'),
|
||||
)
|
||||
) {
|
||||
this.message = '';
|
||||
return;
|
||||
}
|
||||
result = await this.api('share', {
|
||||
id: pod.id,
|
||||
shared: true,
|
||||
confirmed: true,
|
||||
});
|
||||
}
|
||||
await this.load();
|
||||
this.message = this.text(result.publication_pending ? 'pending' : 'done');
|
||||
});
|
||||
},
|
||||
refresh(pod) {
|
||||
this.task(async () => {
|
||||
const data = await this.api('refresh', { id: pod.id });
|
||||
await this.update();
|
||||
this.message = this.text('checked') + data.added;
|
||||
});
|
||||
},
|
||||
refreshAll() {
|
||||
this.task(async () => {
|
||||
let count = 0;
|
||||
for (const pod of this.mine) {
|
||||
const data = await this.api('refresh', { id: pod.id });
|
||||
count += data.added;
|
||||
}
|
||||
await this.update();
|
||||
this.message = this.text('checked') + count;
|
||||
});
|
||||
},
|
||||
download(episode) {
|
||||
this.task(async () => {
|
||||
await this.api('download', { id: episode.id });
|
||||
episode.downloading = true;
|
||||
this.message = this.text('downloading');
|
||||
});
|
||||
},
|
||||
search() {
|
||||
this.task(async () => {
|
||||
const data = await this.api('search', { query: this.query });
|
||||
this.hits = data.hits;
|
||||
this.message = this.text('done');
|
||||
});
|
||||
},
|
||||
publicCards() {
|
||||
return [...new Map([...this.public, ...this.hits].map((p) => [p.id, p])).values()];
|
||||
},
|
||||
seasons() {
|
||||
return [
|
||||
...new Set(
|
||||
this.episodes.map((e) => e.metadata.season).filter((s) => s != null),
|
||||
),
|
||||
].sort((a, b) => a - b);
|
||||
},
|
||||
filteredEpisodes() {
|
||||
const filter = this.filter.toLocaleLowerCase();
|
||||
return this.episodes.filter(
|
||||
(e) =>
|
||||
(!filter || e.metadata.title.toLocaleLowerCase().includes(filter)) &&
|
||||
(!this.season || String(e.metadata.season) === String(this.season)) &&
|
||||
(!this.unplayedOnly || !e.completed),
|
||||
);
|
||||
},
|
||||
date(ms) {
|
||||
return ms ? new Date(ms).toLocaleDateString() : '';
|
||||
},
|
||||
play(episode) {
|
||||
return this.task(async () => {
|
||||
const devices = Alpine.store('devices');
|
||||
if (devices && !devices.isActive()) await devices.select(devices.id);
|
||||
const position = episode.completed ? 0 : episode.position_ms;
|
||||
const session = await this.api('progress', {
|
||||
id: episode.id,
|
||||
position_ms: position,
|
||||
explicit: true,
|
||||
});
|
||||
const player = Alpine.store('player');
|
||||
player._playLocal(
|
||||
{
|
||||
id: episode.id,
|
||||
podcast: true,
|
||||
podcast_generation: session.generation,
|
||||
podcast_id: episode.metadata.podcast_id,
|
||||
title: episode.metadata.title,
|
||||
artists: [{ id: null, name: this.selected.metadata.title }],
|
||||
featured_artists: [],
|
||||
release_id: null,
|
||||
release_title: this.selected.metadata.title,
|
||||
duration_seconds: (episode.metadata.duration_ms || 0) / 1000,
|
||||
stream_url: '/api/podcasts/media/' + encodeURIComponent(episode.id),
|
||||
cover_url:
|
||||
episode.metadata.image_url || this.selected.metadata.image_url,
|
||||
},
|
||||
{ position_seconds: position / 1000 },
|
||||
);
|
||||
this.lastCheckpoint = Date.now();
|
||||
this.message = '';
|
||||
});
|
||||
},
|
||||
checkpoint(player, completed = false, unloading = false) {
|
||||
const track = player.currentTrack;
|
||||
if (!track?.podcast) return;
|
||||
const payload = {
|
||||
action: 'progress',
|
||||
id: track.id,
|
||||
position_ms: Math.round((player.currentTime || 0) * 1000),
|
||||
completed,
|
||||
generation: track.podcast_generation,
|
||||
sequence: Date.now(),
|
||||
};
|
||||
const episode = this.episodes.find((e) => e.id === track.id);
|
||||
if (episode) {
|
||||
episode.position_ms = payload.position_ms;
|
||||
episode.completed = completed;
|
||||
}
|
||||
if (unloading) {
|
||||
navigator.sendBeacon(
|
||||
'/api/podcasts/action',
|
||||
new Blob([JSON.stringify(payload)], { type: 'application/json' }),
|
||||
);
|
||||
} else {
|
||||
this.api('progress', payload).catch(() => {});
|
||||
}
|
||||
this.lastCheckpoint = Date.now();
|
||||
},
|
||||
tick(player) {
|
||||
if (
|
||||
player.currentTrack?.podcast &&
|
||||
player.isPlaying &&
|
||||
Date.now() - this.lastCheckpoint > 10000
|
||||
)
|
||||
this.checkpoint(player, !!player.currentTrack.podcast_completed);
|
||||
},
|
||||
mark(episode) {
|
||||
return this.task(async () => {
|
||||
const completed = !episode.completed;
|
||||
const position = completed ? episode.position_ms : 0;
|
||||
const result = await this.api('progress', {
|
||||
id: episode.id,
|
||||
position_ms: position,
|
||||
completed,
|
||||
explicit: true,
|
||||
});
|
||||
episode.completed = completed;
|
||||
episode.position_ms = position;
|
||||
const player = Alpine.store('player');
|
||||
if (player.currentTrack?.id === episode.id) {
|
||||
player.currentTrack.podcast_generation = result.generation;
|
||||
player.currentTrack.podcast_completed = completed;
|
||||
if (!completed) player.seek(0);
|
||||
}
|
||||
this.message = this.text('done');
|
||||
});
|
||||
},
|
||||
restart(episode) {
|
||||
episode.position_ms = 0;
|
||||
episode.completed = false;
|
||||
return this.play(episode);
|
||||
},
|
||||
});
|
||||
});
|
||||
</script>
|
||||
@@ -0,0 +1,173 @@
|
||||
<style>
|
||||
.podcast-nav{appearance:none;border:0;background:transparent;width:100%;font:inherit;text-align:left}
|
||||
|
||||
.podcast-page{padding:20px;max-width:1100px;margin:auto}.podcast-toolbar{display:flex;gap:10px;align-items:center;flex-wrap:wrap;margin:16px 0}.podcast-toolbar input,.podcast-toolbar select{background:var(--bg-secondary,#171c28);color:inherit;border:1px solid var(--border,#384052);border-radius:8px;padding:10px;max-width:100%}.podcast-toolbar input[type=text]{flex:1;min-width:160px}.podcast-page button{border:1px solid var(--border,#384052);background:var(--bg-secondary,#171c28);color:inherit;border-radius:8px;padding:8px 12px;cursor:pointer}.podcast-page button:disabled{opacity:.5}.podcast-grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(min(280px,100%),1fr));gap:14px;margin:16px 0 28px}.podcast-card,.podcast-episode{border:1px solid var(--border,#384052);border-radius:12px;padding:16px;overflow-wrap:anywhere}.podcast-card h3,.podcast-episode h3{margin:0 0 8px}.podcast-description{color:var(--text-secondary,#a2a9b8);white-space:pre-line;margin:8px 0}.podcast-episode{margin:10px 0}.podcast-notice{padding:12px 0;color:var(--accent,#67e8f9)}@media(max-width:600px){.podcast-page{padding:12px}.podcast-page button,.podcast-page input,.podcast-page select{min-height:44px;font-size:16px}}
|
||||
</style>
|
||||
<template x-if="$store.library.view === 'podcasts'">
|
||||
<section class="podcast-page">
|
||||
<h1 x-text="$store.podcasts.text('podcasts')"></h1>
|
||||
<form class="podcast-toolbar" @submit.prevent="$store.podcasts.add()">
|
||||
<input
|
||||
type="text"
|
||||
x-model="$store.podcasts.url"
|
||||
placeholder="RSS / Atom URL"
|
||||
aria-label="RSS / Atom URL"
|
||||
required
|
||||
/><button :disabled="$store.podcasts.busy" x-text="$store.podcasts.text('add')"></button
|
||||
><button
|
||||
type="button"
|
||||
@click="$store.podcasts.refreshAll()"
|
||||
:disabled="$store.podcasts.busy"
|
||||
x-text="$store.podcasts.text('checkAll')"
|
||||
></button>
|
||||
</form>
|
||||
<div
|
||||
role="status"
|
||||
aria-live="polite"
|
||||
class="podcast-notice"
|
||||
x-text="$store.podcasts.message"
|
||||
></div>
|
||||
<h2 x-text="$store.podcasts.text('mine')"></h2>
|
||||
<p x-show="!$store.podcasts.mine.length" x-text="$store.podcasts.text('empty')"></p>
|
||||
<div class="podcast-grid">
|
||||
<template x-for="pod in $store.podcasts.mine" :key="pod.id"
|
||||
><article class="podcast-card">
|
||||
<h3>
|
||||
<button
|
||||
@click="$store.podcasts.open(pod)"
|
||||
x-text="pod.metadata.title"
|
||||
></button>
|
||||
</h3>
|
||||
<div x-text="pod.metadata.author"></div>
|
||||
<div
|
||||
class="podcast-description"
|
||||
x-text="pod.episodes+' · '+pod.new_episodes+' '+$store.podcasts.text('unplayed')"
|
||||
></div>
|
||||
<div x-show="pod.error" x-text="pod.error"></div>
|
||||
<div class="podcast-toolbar">
|
||||
<button
|
||||
@click="$store.podcasts.refresh(pod)"
|
||||
:disabled="$store.podcasts.busy"
|
||||
x-text="$store.podcasts.text('check')"
|
||||
></button
|
||||
><button
|
||||
@click="$store.podcasts.share(pod)"
|
||||
:disabled="$store.podcasts.busy"
|
||||
x-text="$store.podcasts.text(pod.shared?'unpublish':'publish')"
|
||||
></button
|
||||
><button
|
||||
@click="$store.podcasts.remove(pod)"
|
||||
:disabled="$store.podcasts.busy"
|
||||
x-text="$store.podcasts.text('remove')"
|
||||
></button>
|
||||
</div></article
|
||||
></template>
|
||||
</div>
|
||||
<template x-if="$store.podcasts.selected"
|
||||
><section>
|
||||
<h2 x-text="$store.podcasts.selected.metadata.title"></h2>
|
||||
<p
|
||||
class="podcast-description"
|
||||
x-text="$store.podcasts.selected.metadata.description"
|
||||
></p>
|
||||
<div class="podcast-toolbar">
|
||||
<input
|
||||
type="text"
|
||||
x-model="$store.podcasts.filter"
|
||||
:placeholder="$store.podcasts.text('filter')"
|
||||
:aria-label="$store.podcasts.text('filter')"
|
||||
/><select
|
||||
x-model="$store.podcasts.season"
|
||||
:aria-label="$store.podcasts.text('season')"
|
||||
>
|
||||
<option value="" x-text="$store.podcasts.text('allSeasons')"></option>
|
||||
<template x-for="season in $store.podcasts.seasons()" :key="season"
|
||||
><option
|
||||
:value="season"
|
||||
x-text="$store.podcasts.text('season')+' '+season"
|
||||
></option
|
||||
></template></select
|
||||
><label
|
||||
><input type="checkbox" x-model="$store.podcasts.unplayedOnly" />
|
||||
<span x-text="$store.podcasts.text('unplayedOnly')"></span
|
||||
></label>
|
||||
</div>
|
||||
<p
|
||||
x-show="!$store.podcasts.filteredEpisodes().length"
|
||||
x-text="$store.podcasts.text('noEpisodes')"
|
||||
></p>
|
||||
<template x-for="episode in $store.podcasts.filteredEpisodes()" :key="episode.id"
|
||||
><article class="podcast-episode">
|
||||
<h3 x-text="episode.metadata.title"></h3>
|
||||
<div x-text="$store.podcasts.date(episode.metadata.published_at_ms)"></div>
|
||||
<details x-show="episode.metadata.description">
|
||||
<summary x-text="$store.podcasts.text('description')"></summary>
|
||||
<p
|
||||
class="podcast-description"
|
||||
x-text="episode.metadata.description"
|
||||
></p>
|
||||
</details>
|
||||
<div class="podcast-toolbar">
|
||||
<button
|
||||
@click="$store.podcasts.play(episode)"
|
||||
x-text="$store.podcasts.text(episode.position_ms&&!episode.completed?'resume':'play')"
|
||||
></button
|
||||
><button
|
||||
@click="$store.podcasts.download(episode)"
|
||||
:disabled="episode.cached||episode.downloading"
|
||||
x-text="$store.podcasts.text(episode.cached?'saved':episode.downloading?'downloading':'download')"
|
||||
></button
|
||||
><button
|
||||
@click="$store.podcasts.mark(episode)"
|
||||
x-text="$store.podcasts.text(episode.completed?'markUnplayed':'markPlayed')"
|
||||
></button
|
||||
><button
|
||||
x-show="episode.position_ms"
|
||||
@click="$store.podcasts.restart(episode)"
|
||||
x-text="$store.podcasts.text('restart')"
|
||||
></button>
|
||||
</div>
|
||||
<div
|
||||
role="status"
|
||||
x-show="episode.error"
|
||||
x-text="episode.error"
|
||||
></div></article></template
|
||||
><button
|
||||
x-show="$store.podcasts.hasMore"
|
||||
@click="$store.podcasts.more()"
|
||||
:disabled="$store.podcasts.busy"
|
||||
x-text="$store.podcasts.text('loadMore')"
|
||||
></button></section
|
||||
></template>
|
||||
<h2 x-text="$store.podcasts.text('public')"></h2>
|
||||
<form class="podcast-toolbar" @submit.prevent="$store.podcasts.search()">
|
||||
<input
|
||||
type="text"
|
||||
x-model="$store.podcasts.query"
|
||||
:placeholder="$store.podcasts.text('searchNetwork')"
|
||||
:aria-label="$store.podcasts.text('searchNetwork')"
|
||||
minlength="2"
|
||||
maxlength="200"
|
||||
/><button
|
||||
:disabled="$store.podcasts.busy"
|
||||
x-text="$store.podcasts.text('search')"
|
||||
></button>
|
||||
</form>
|
||||
<p
|
||||
x-show="!$store.podcasts.public.length&&!$store.podcasts.hits.length"
|
||||
x-text="$store.podcasts.text('noPublic')"
|
||||
></p>
|
||||
<div class="podcast-grid">
|
||||
<template x-for="pod in $store.podcasts.publicCards()" :key="pod.id"
|
||||
><article class="podcast-card">
|
||||
<h3 x-text="pod.metadata.title"></h3>
|
||||
<div x-text="pod.metadata.author"></div>
|
||||
<p class="podcast-description" x-text="pod.metadata.description"></p>
|
||||
<button
|
||||
@click="$store.podcasts.add(pod.url)"
|
||||
:disabled="$store.podcasts.busy||$store.podcasts.mine.some(p=>p.id===pod.id)"
|
||||
x-text="$store.podcasts.text('subscribe')"
|
||||
></button></article
|
||||
></template>
|
||||
</div></section
|
||||
></template>
|
||||
@@ -775,11 +775,18 @@ document.addEventListener('alpine:init', () => {
|
||||
this.currentTime = audio.currentTime;
|
||||
this.duration = audio.duration || 0;
|
||||
this.progress = this.duration > 0 ? (this.currentTime / this.duration) * 100 : 0;
|
||||
Alpine.store('podcasts')?.tick(this);
|
||||
this._trackListenedDelta();
|
||||
this._maybePrefetchNext();
|
||||
});
|
||||
|
||||
audio.addEventListener('ended', () => {
|
||||
if (this.currentTrack?.podcast) {
|
||||
this.isPlaying = false;
|
||||
this.currentTrack.podcast_completed = true;
|
||||
Alpine.store('podcasts')?.checkpoint(this, true);
|
||||
return;
|
||||
}
|
||||
this._trackListenedDelta();
|
||||
this._recordHistory('finished');
|
||||
if (Alpine.store('devices')?.shouldPlayJamLocally()) {
|
||||
@@ -796,6 +803,7 @@ document.addEventListener('alpine:init', () => {
|
||||
this._sendNowPlaying();
|
||||
});
|
||||
audio.addEventListener('pause', () => {
|
||||
if (this.currentTrack?.podcast) Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed);
|
||||
this._trackListenedDelta();
|
||||
this.isPlaying = false;
|
||||
this._lastAudioTime = audio.currentTime || 0;
|
||||
@@ -884,6 +892,7 @@ document.addEventListener('alpine:init', () => {
|
||||
},
|
||||
|
||||
_maybePrefetchNext() {
|
||||
if (this.currentTrack?.podcast) return;
|
||||
if (this.progress < 90 || !this.isPlaying) return;
|
||||
const queue = Alpine.store('queue');
|
||||
const nextIndex = queue?.currentIndex + 1;
|
||||
@@ -900,6 +909,7 @@ document.addEventListener('alpine:init', () => {
|
||||
},
|
||||
|
||||
_playLocal(track, options = {}) {
|
||||
if (this.currentTrack?.podcast) Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed);
|
||||
this._recordHistory('replaced');
|
||||
this.currentTrack = track;
|
||||
this._historyTrack = track;
|
||||
@@ -910,6 +920,9 @@ document.addEventListener('alpine:init', () => {
|
||||
this._resetPlaybackTracking();
|
||||
audio.src = track.stream_url;
|
||||
const seekSeconds = Number(options.position_seconds || 0);
|
||||
this.currentTime = seekSeconds;
|
||||
this.duration = Number(track.duration_seconds || 0);
|
||||
this.progress = this.duration > 0 ? seekSeconds / this.duration * 100 : 0;
|
||||
if (seekSeconds > 0) {
|
||||
const onLoaded = () => {
|
||||
audio.currentTime = seekSeconds;
|
||||
@@ -1208,6 +1221,7 @@ document.addEventListener('alpine:init', () => {
|
||||
},
|
||||
|
||||
_devicePlaybackStatePayload() {
|
||||
if (this.currentTrack?.podcast) return null;
|
||||
const queue = Alpine.store('queue');
|
||||
const track = this.currentTrack || queue?.tracks?.[queue.currentIndex] || null;
|
||||
if (!track && (!queue || queue.tracks.length === 0)) return null;
|
||||
@@ -1406,6 +1420,7 @@ document.addEventListener('alpine:init', () => {
|
||||
},
|
||||
|
||||
_saveState() {
|
||||
if (this.currentTrack?.podcast) { Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed); return; }
|
||||
if (GUEST) return;
|
||||
const queue = Alpine.store('queue');
|
||||
if (!this.currentTrack && queue.tracks.length === 0) return;
|
||||
@@ -1418,6 +1433,7 @@ document.addEventListener('alpine:init', () => {
|
||||
},
|
||||
|
||||
_saveStateSync() {
|
||||
if (this.currentTrack?.podcast) { Alpine.store('podcasts')?.checkpoint(this, !!this.currentTrack.podcast_completed, true); return; }
|
||||
if (GUEST) return;
|
||||
const queue = Alpine.store('queue');
|
||||
if (!this.currentTrack && queue.tracks.length === 0) return;
|
||||
|
||||
@@ -75,6 +75,7 @@
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><path d="M17 8l-5-5-5 5"/><path d="M12 3v12"/></svg>
|
||||
{{ t.player_my_uploads }}
|
||||
</div>
|
||||
<button class="sidebar-nav-item podcast-nav" :class="{active:$store.library.view==='podcasts'}" @click="$store.podcasts.enter()"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="2" width="6" height="13" rx="3"/><path d="M5 10v2a7 7 0 0014 0v-2M12 19v3M8 22h8"/></svg><span x-text="$store.podcasts.text('podcasts')"></span></button>
|
||||
</div>
|
||||
<div class="sidebar-section">
|
||||
<div class="sidebar-section-title">
|
||||
@@ -187,6 +188,7 @@
|
||||
<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M21 15v4a2 2 0 01-2 2H5a2 2 0 01-2-2v-4"/><path d="M17 8l-5-5-5 5"/><path d="M12 3v12"/></svg>
|
||||
{{ t.player_my_uploads }}
|
||||
</div>
|
||||
<button class="sidebar-nav-item podcast-nav" :class="{active:$store.library.view==='podcasts'}" @click="$store.podcasts.enter()"><svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><rect x="9" y="2" width="6" height="13" rx="3"/><path d="M5 10v2a7 7 0 0014 0v-2M12 19v3M8 22h8"/></svg><span x-text="$store.podcasts.text('podcasts')"></span></button>
|
||||
</div>
|
||||
|
||||
<div class="mobile-drawer-section">
|
||||
@@ -407,6 +409,7 @@
|
||||
</div>
|
||||
|
||||
<!-- Search Results -->
|
||||
{% include "player/podcasts.html" %}
|
||||
<template x-if="$store.library.view === 'search'">
|
||||
<div>
|
||||
<div class="search-similarity-heading"
|
||||
|
||||
@@ -0,0 +1,70 @@
|
||||
const assert = require('node:assert/strict');
|
||||
const {readFileSync} = require('node:fs');
|
||||
const {test} = require('node:test');
|
||||
const vm = require('node:vm');
|
||||
const source = readFileSync(`${__dirname}/../templates/player/podcast_scripts.html`, 'utf8').replace(/<\/?script>/g, '');
|
||||
function setup(responder=()=>({})) {
|
||||
const calls=[],stores={library:{view:'artists'},mobile:{closeLibrary(){}},player:{_playLocal(track,options){this.currentTrack=track;this.options=options;},seek(){}}};
|
||||
vm.runInNewContext(source,{
|
||||
document:{documentElement:{lang:'ru'},addEventListener(_,fn){fn();}},
|
||||
Alpine:{store(name,value){if(value)stores[name]=value;return stores[name];}},
|
||||
fetch:async(url,options)=>{const body=JSON.parse(options.body);calls.push(body);return {ok:true,json:async()=>responder(body)};},
|
||||
confirm:()=>true,setInterval:()=>1,Date,Map,Set,Blob,navigator:{sendBeacon(){}},
|
||||
});
|
||||
return {store:stores.podcasts,stores,calls};
|
||||
}
|
||||
const episode={id:'ep1:fixture',position_ms:123000,completed:false,metadata:{podcast_id:'pod1:fixture',title:'Episode',duration_ms:3600000,season:2}};
|
||||
|
||||
test('podcast playback resumes through the main player with episode identity and its own progress generation',async()=>{
|
||||
const {store,stores,calls}=setup(()=>({generation:7}));
|
||||
store.selected={metadata:{title:'Show'}};
|
||||
await store.play({...episode});
|
||||
assert.equal(stores.player.currentTrack.id,episode.id);
|
||||
assert.equal(stores.player.currentTrack.podcast,true);
|
||||
assert.equal(stores.player.currentTrack.podcast_generation,7);
|
||||
assert.equal(stores.player.currentTrack.artists[0].name,'Show');
|
||||
assert.equal(stores.player.options.position_seconds,123);
|
||||
assert.equal(calls[0].explicit,true);
|
||||
stores.player.currentTime=130;
|
||||
store.checkpoint(stores.player);
|
||||
assert.equal(calls[1].position_ms,130000);
|
||||
assert.equal(calls[1].generation,7);
|
||||
});
|
||||
test('a completed episode starts at zero and restart resets a partial episode',async()=>{
|
||||
const {store,stores}=setup(()=>({generation:2}));store.selected={metadata:{title:'Show'}};
|
||||
await store.play({...episode,completed:true});assert.equal(stores.player.options.position_seconds,0);
|
||||
const item={...episode};await store.restart(item);assert.equal(item.position_ms,0);assert.equal(stores.player.options.position_seconds,0);
|
||||
});
|
||||
test('marking unplayed is an explicit reset and advances the active session generation',async()=>{
|
||||
const {store,stores,calls}=setup(()=>({generation:9}));
|
||||
const item={...episode,completed:true};stores.player.currentTrack={id:item.id,podcast:true};
|
||||
await store.mark(item);assert.equal(item.completed,false);assert.equal(item.position_ms,0);
|
||||
assert.equal(calls[0].explicit,true);assert.equal(calls[0].position_ms,0);assert.equal(stores.player.currentTrack.podcast_generation,9);
|
||||
});
|
||||
test('filtering combines season, title and played status without mixing podcasts with music',()=>{
|
||||
const {store}=setup();store.episodes=[{...episode},{...episode,id:'other',completed:true},{...episode,id:'season3',metadata:{...episode.metadata,season:3}}];
|
||||
store.filter='epis';store.season='2';store.unplayedOnly=true;assert.deepEqual(Array.from(store.filteredEpisodes(),e=>e.id),[episode.id]);
|
||||
store.public=[{id:'a',url:'origin'}];store.hits=[{id:'a',url:'origin'},{id:'b',url:'other'}];assert.equal(store.publicCards().length,2);
|
||||
});
|
||||
test('private URL publication requires a separate confirmation; revocation does not republish',async()=>{
|
||||
const {store,calls}=setup(body=>body.action==='share'&&!body.confirmed?{confirmation_required:true,urls:['https://example.test/feed?token=private']}:body.action==='list'?{mine:[],public:[]}:{ok:true});
|
||||
await store.share({id:'a',shared:false,metadata:{feed_url:'https://example.test/feed?token=private'}});
|
||||
// UI actions return task promises through the busy flag; flush the asynchronous load.
|
||||
while(store.busy)await new Promise(resolve=>setImmediate(resolve));
|
||||
const shares=calls.filter(c=>c.action==='share');assert.equal(shares.length,2);assert.equal(shares[1].confirmed,true);
|
||||
});
|
||||
test('admin and player inline scripts parse without a browser',()=>{
|
||||
for(const file of ['templates/admin/podcasts.html','templates/player/podcast_scripts.html']) {
|
||||
const html=readFileSync(`${__dirname}/../${file}`,'utf8');for(const match of html.matchAll(/<script>([\s\S]*?)<\/script>/g))new vm.Script(match[1]);
|
||||
}
|
||||
});
|
||||
|
||||
test('new episodes do not create gaps in previously loaded pages',async()=>{
|
||||
let items=Array.from({length:202},(_,i)=>({id:'episode-'+i,metadata:{title:String(i)}}));
|
||||
const {store}=setup(body=>({episodes:items.slice(body.offset,body.offset+200),has_more:body.offset+200<items.length}));
|
||||
store.selected={id:'show'};
|
||||
await store.loadEpisodes();await store.loadEpisodes(true);assert.equal(store.episodes.length,202);
|
||||
items=[{id:'new',metadata:{title:'new'}},...items];
|
||||
await store.loadEpisodes();assert.equal(store.episodes.length,203);
|
||||
assert.equal(store.episodes[0].id,'new');assert.ok(store.episodes.some(e=>e.id==='episode-199'));
|
||||
});
|
||||
Reference in new issue
Block a user