Add the podcast HTTP API for the UI and the web player
/api/podcasts now lists subscriptions with counters and fetch state, subscribes by feed URL (fetched first; nothing is stored for a URL that is not a public feed), shows a podcast with its seasons and history, pages and searches episodes, and runs the explicit progress actions (start over, played, unplayed) and unsubscribe/subscribe again. The web player gets two endpoints: playback returns the audio source and the resume position and, when the browser starts playing, writes a new listening session as an explicit action above the carried handoff generation; progress stores checkpoints, pause, stop and handoff at the session generation, a seek as an explicit action, completes the episode once at the end or within the completion tail, and records the listening session. Handlers delegate to podcasts::api, which the new Postgres test drives directly. Podcast queue items are no longer marked unavailable in browser JSON and carry the episode artwork. The temporary dead-code allowance of the podcast module is gone; helpers used only by tests are cfg(test) and complete_session gave way to complete_if_current. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
5aaea8a8eb
commit
1778942714
13 files changed
+1998
-50
No files matched your search
@@ -1842,7 +1842,6 @@ async fn advance_vector<'e>(
|
||||
|
||||
/// Device id of the account's web device, creating the identity on first
|
||||
/// use. Local podcast actions stamp their operations with it.
|
||||
#[cfg_attr(not(test), allow(dead_code))] // podcast UI and RSS job: later commits
|
||||
pub(crate) async fn local_device_id(pool: &sqlx::PgPool, user_id: i64) -> Result<String> {
|
||||
Ok(ensure_identity(pool, user_id, "").await?.device_id)
|
||||
}
|
||||
@@ -1854,7 +1853,6 @@ pub(crate) async fn local_device_id(pool: &sqlx::PgPool, user_id: i64) -> Result
|
||||
/// `make` receives the `op_id`. The caller applies the returned operation
|
||||
/// itself in the same transaction, so the log and the materialized state
|
||||
/// change together (the podcast store does this for its local actions).
|
||||
#[cfg_attr(not(test), allow(dead_code))] // podcast UI and RSS job: later commits
|
||||
pub(crate) async fn append_local_op(
|
||||
conn: &mut sqlx::PgConnection,
|
||||
user_id: i64,
|
||||
|
||||
@@ -365,7 +365,7 @@ async fn podcast_queue_survives_server_browser_server_round_trip() {
|
||||
assert_eq!(payload["index"], 3);
|
||||
assert_eq!(payload["position_seconds"], 1200.0);
|
||||
assert_eq!(tracks[0]["source"]["kind"], "podcast_episode");
|
||||
assert_eq!(tracks[0]["unavailable"], true);
|
||||
assert_eq!(tracks[0]["unavailable"], false, "episodes play on the web player");
|
||||
assert_eq!(tracks[1]["source"]["kind"], "private");
|
||||
|
||||
// The browser keeps its queue and sends it back (plus a library track
|
||||
|
||||
@@ -8,7 +8,10 @@
|
||||
//! plus the verbatim device-sync DTO under [`WIRE_TRACK_KEY`] and its explicit
|
||||
//! [`PlaybackSource`] under [`SOURCE_KEY`]. Converting back to the wire uses
|
||||
//! the verbatim DTO, so such items survive browser -> server -> peers ->
|
||||
//! server -> browser unchanged even though this web player cannot play them.
|
||||
//! server -> browser unchanged. The web player plays podcast episodes
|
||||
//! through `/api/podcasts/episodes/{id}/playback` (publisher URL or the
|
||||
//! optional proxy); placeholders and unresolved federated music stay
|
||||
//! unplayable here.
|
||||
//!
|
||||
//! Gating and Jam decisions are delegated to `music_dht::device_sync`; this
|
||||
//! module only maps browser JSON onto the shared DTOs.
|
||||
@@ -34,9 +37,6 @@ pub(crate) const POSITION_UNKNOWN_KEY: &str = "position_unknown";
|
||||
|
||||
/// Reason shown for federated music that is not in this library.
|
||||
pub(crate) const FED_UNAVAILABLE_REASON: &str = "Not available on this web player yet";
|
||||
/// Reason shown for podcast episodes, which this web player cannot play yet.
|
||||
pub(crate) const PODCAST_UNAVAILABLE_REASON: &str =
|
||||
"Podcast episodes cannot be played on the web player yet";
|
||||
/// Reason shown for Jam placeholders of someone else's private item.
|
||||
pub(crate) const PRIVATE_UNAVAILABLE_REASON: &str = "Private item of the Jam host";
|
||||
|
||||
@@ -68,13 +68,15 @@ pub(crate) fn external_track_json(
|
||||
"release_id": 0,
|
||||
"release_title": episode.podcast_title,
|
||||
"release_year": serde_json::Value::Null,
|
||||
"cover_url": serde_json::Value::Null,
|
||||
// Artwork is loaded from the publisher, like the audio.
|
||||
"cover_url": episode.image_url,
|
||||
// The player asks `/api/podcasts/episodes/{id}/playback` for the
|
||||
// audio source when it starts the episode.
|
||||
"stream_url": "",
|
||||
"uploader_name": "Podcast",
|
||||
"audio_format": episode.mime,
|
||||
"content_id": serde_json::Value::Null,
|
||||
"unavailable": true,
|
||||
"unavailable_reason": PODCAST_UNAVAILABLE_REASON,
|
||||
"unavailable": false,
|
||||
}),
|
||||
Some(PlaybackSource::Private) => serde_json::json!({
|
||||
"id": placeholder_track_id(Some("private"), index),
|
||||
@@ -490,8 +492,15 @@ mod tests {
|
||||
let mut wire = PlaybackTrack::podcast_episode(episode());
|
||||
wire.play_count = 3;
|
||||
let json = external_track_json(&wire, 4, None);
|
||||
assert_eq!(json["unavailable"], true);
|
||||
assert_eq!(json["unavailable_reason"], PODCAST_UNAVAILABLE_REASON);
|
||||
// Playable on the web player (the source is resolved on play).
|
||||
assert_eq!(json["unavailable"], false);
|
||||
assert!(json.get("unavailable_reason").is_none());
|
||||
assert_eq!(json["stream_url"], "");
|
||||
assert_eq!(
|
||||
json["cover_url"],
|
||||
Value::Null,
|
||||
"the test episode has no artwork"
|
||||
);
|
||||
assert_eq!(json["title"], "Episode 42");
|
||||
assert_eq!(json[SOURCE_KEY]["kind"], "podcast_episode");
|
||||
assert!(json["id"].as_i64().unwrap() < 0);
|
||||
|
||||
+92
-15
@@ -78,7 +78,6 @@ enum ExplicitAction {
|
||||
Start(i64),
|
||||
Seek(i64),
|
||||
Restart,
|
||||
Complete(i64),
|
||||
MarkPlayed,
|
||||
MarkUnplayed,
|
||||
}
|
||||
@@ -293,6 +292,9 @@ impl PodcastStore {
|
||||
/// is already effectively shared (`effective_share`). Revoking is a no-op
|
||||
/// when no share decision says `true`. The write uses the next podcast
|
||||
/// generation, so it orders after the subscription it observed.
|
||||
// The publication toggle is part of public discovery (MR-W3); until
|
||||
// then only the tests call it.
|
||||
#[cfg_attr(not(test), allow(dead_code))]
|
||||
pub(crate) async fn set_shared(
|
||||
&self,
|
||||
user_id: i64,
|
||||
@@ -347,7 +349,6 @@ impl PodcastStore {
|
||||
(position, ProgressStatus::InProgress)
|
||||
}
|
||||
ExplicitAction::Restart => (0, ProgressStatus::InProgress),
|
||||
ExplicitAction::Complete(position) => (position, ProgressStatus::Completed),
|
||||
ExplicitAction::MarkPlayed => (current_position, ProgressStatus::Completed),
|
||||
ExplicitAction::MarkUnplayed => (0, ProgressStatus::NotStarted),
|
||||
};
|
||||
@@ -465,23 +466,74 @@ impl PodcastStore {
|
||||
.await
|
||||
}
|
||||
|
||||
/// The session reached the end (`reaches_completion` or end of stream):
|
||||
/// writes `completed` with an explicit generation. Record the session
|
||||
/// itself with [`PodcastStore::record_listen_session`].
|
||||
pub(crate) async fn complete_session(
|
||||
/// Completes a running session (end of stream or `reaches_completion`)
|
||||
/// unless another write took over. Record the session itself with
|
||||
/// [`PodcastStore::record_listen_session`].
|
||||
///
|
||||
/// Like [`PodcastStore::checkpoint`], nothing is written when the
|
||||
/// register holds a greater generation ([`CheckpointOutcome::Superseded`])
|
||||
/// or when this session already completed the episode
|
||||
/// ([`CheckpointOutcome::AlreadyCompleted`]). Otherwise `completed` is
|
||||
/// written with an explicit generation; the check and the write
|
||||
/// happen in one transaction, so a periodic save after the end never
|
||||
/// completes the episode twice.
|
||||
pub(crate) async fn complete_if_current(
|
||||
&self,
|
||||
user_id: i64,
|
||||
session: &ProgressSession,
|
||||
position_ms: i64,
|
||||
) -> Result<ProgressWrite> {
|
||||
self.explicit_progress(
|
||||
user_id,
|
||||
&session.episode,
|
||||
Some(&session.session_id),
|
||||
Some(session.generation),
|
||||
ExplicitAction::Complete(position_ms),
|
||||
)
|
||||
.await
|
||||
) -> Result<CheckpointOutcome> {
|
||||
let episode = &session.episode;
|
||||
episode.validate().map_err(invalid)?;
|
||||
let device_id = devices::local_device_id(&self.pool, user_id).await?;
|
||||
let mut tx = self.begin_write(user_id).await?;
|
||||
let current = apply::load_progress(&mut tx, user_id, &episode.episode_id).await?;
|
||||
if let Some(current) = current.as_ref() {
|
||||
if current.generation > session.generation {
|
||||
return Ok(CheckpointOutcome::Superseded {
|
||||
current: current.clone(),
|
||||
});
|
||||
}
|
||||
if current.session_id == session.session_id
|
||||
&& current.status == ProgressStatus::Completed
|
||||
{
|
||||
return Ok(CheckpointOutcome::AlreadyCompleted {
|
||||
current: current.clone(),
|
||||
});
|
||||
}
|
||||
}
|
||||
let generation = ProgressRecord::explicit_generation(
|
||||
current
|
||||
.as_ref()
|
||||
.map(|record| record.generation)
|
||||
.into_iter()
|
||||
.chain(Some(session.generation))
|
||||
.max(),
|
||||
);
|
||||
let reference = op_ref(episode);
|
||||
let op = emit(&mut tx, user_id, &device_id, |_| {
|
||||
SyncOpPayload::PodcastProgressSet {
|
||||
episode_id: episode.episode_id.clone(),
|
||||
podcast_id: episode.podcast_id.clone(),
|
||||
position_ms,
|
||||
status: ProgressStatus::Completed,
|
||||
generation,
|
||||
session_id: session.session_id.clone(),
|
||||
episode: Some(reference.clone()),
|
||||
}
|
||||
})
|
||||
.await?;
|
||||
tx.commit().await?;
|
||||
let record = op.podcast_progress().expect("progress payload");
|
||||
Ok(CheckpointOutcome::Written(Box::new(ProgressWrite {
|
||||
record,
|
||||
session: ProgressSession {
|
||||
episode: episode.clone(),
|
||||
session_id: session.session_id.clone(),
|
||||
generation,
|
||||
},
|
||||
op,
|
||||
})))
|
||||
}
|
||||
|
||||
/// "Start over": position 0, in progress, explicit generation.
|
||||
@@ -568,9 +620,34 @@ impl PodcastStore {
|
||||
Ok(Some(op))
|
||||
}
|
||||
|
||||
/// Makes sure the catalog knows an episode a queue item refers to.
|
||||
///
|
||||
/// Queue items received through a handoff carry a self-contained
|
||||
/// `PodcastEpisodeRef`; the account may not have refreshed that feed yet.
|
||||
/// The reference is recorded like one learned through sync
|
||||
/// (`source = 'sync'`, never replacing feed metadata). Returns whether a
|
||||
/// row was added. No register is written.
|
||||
pub(crate) async fn ensure_episode(
|
||||
&self,
|
||||
user_id: i64,
|
||||
episode: &PodcastEpisodeRef,
|
||||
) -> Result<bool> {
|
||||
episode.validate().map_err(invalid)?;
|
||||
let mut tx = self.begin_write(user_id).await?;
|
||||
let known = super::queries::episode_ref_in(&mut tx, user_id, &episode.episode_id)
|
||||
.await?
|
||||
.is_some();
|
||||
if !known {
|
||||
apply::ensure_episode_from_ref(&mut tx, user_id, episode).await?;
|
||||
}
|
||||
tx.commit().await?;
|
||||
Ok(!known)
|
||||
}
|
||||
|
||||
/// Resolves a feed URL to a podcast id: the existing podcast when the
|
||||
/// URL is a known feed URL or alias (`resolve_podcast_id`), otherwise
|
||||
/// the id a first subscription through this URL would derive.
|
||||
#[cfg(test)]
|
||||
pub(crate) async fn resolve_podcast_id(
|
||||
&self,
|
||||
user_id: i64,
|
||||
|
||||
@@ -0,0 +1,996 @@
|
||||
//! Request handling of the podcast UI and the web player.
|
||||
//!
|
||||
//! [`super::http`] authenticates the request and passes the account here.
|
||||
//! Every function takes the store, the account and the decoded input and
|
||||
//! returns a JSON view or an [`ApiError`] with its HTTP status, so the
|
||||
//! behavior of the endpoints is testable without an HTTP server
|
||||
//! (`postgres_tests`).
|
||||
//!
|
||||
//! Playback follows the progress rules of the frid podcast contract
|
||||
//! (`PODCASTS.md`, "Progress" and "Listening sessions and counts"):
|
||||
//!
|
||||
//! * [`playback`] prepares an episode for the player: the audio source, the
|
||||
//! position ordinary Play resumes from and, when the browser starts
|
||||
//! playing (`start`), a new listening session written as an explicit
|
||||
//! action (`explicit_generation(max(local, carried))`).
|
||||
//! * [`progress`] stores what the player reports for that session: periodic
|
||||
//! checkpoints and pause/stop/handoff saves keep the session generation, a
|
||||
//! user seek is an explicit action, the end of the stream or
|
||||
//! `reaches_completion` completes the episode once, and the listening
|
||||
//! session is recorded (history counts only completed sessions).
|
||||
|
||||
use music_dht::device_sync::PlaybackTrack;
|
||||
use music_dht::podcast::{
|
||||
EpisodeId, EpisodeType, FeedUrl, ListenSession, PodcastEpisodeRef, PodcastId, PodcastMeta,
|
||||
ProgressRecord, ProgressStatus, reaches_completion,
|
||||
};
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_json::Value;
|
||||
|
||||
use super::fetch::{FeedFetcher, FetchErrorKind};
|
||||
use super::runner::{self, SubscribeUrlError};
|
||||
use super::{
|
||||
CheckpointOutcome, EpisodeListItem, EpisodeQuery, EpisodeSort, FetchState, PlayedFilter,
|
||||
PodcastListFilter, PodcastStore, PodcastStoreError, PodcastSummary, ProgressSession,
|
||||
SeasonFilter, SeasonSummary,
|
||||
};
|
||||
use crate::federation::devices;
|
||||
use crate::player::queue_items;
|
||||
|
||||
/// Episodes per page when the request does not say.
|
||||
pub(crate) const DEFAULT_EPISODE_PAGE: usize = 50;
|
||||
/// Largest episode page.
|
||||
pub(crate) const MAX_EPISODE_PAGE: usize = 200;
|
||||
|
||||
/// A failed request: HTTP status and a message for the user.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub(crate) struct ApiError {
|
||||
pub(crate) status: u16,
|
||||
pub(crate) message: String,
|
||||
}
|
||||
|
||||
impl ApiError {
|
||||
pub(crate) fn new(status: u16, message: impl Into<String>) -> Self {
|
||||
Self {
|
||||
status,
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
|
||||
fn bad_request(message: impl Into<String>) -> Self {
|
||||
Self::new(400, message)
|
||||
}
|
||||
|
||||
fn not_found(message: impl Into<String>) -> Self {
|
||||
Self::new(404, message)
|
||||
}
|
||||
}
|
||||
|
||||
impl From<anyhow::Error> for ApiError {
|
||||
fn from(error: anyhow::Error) -> Self {
|
||||
if let Some(error) = error.downcast_ref::<PodcastStoreError>() {
|
||||
return match error {
|
||||
PodcastStoreError::UnknownPodcast(_) => Self::not_found(error.to_string()),
|
||||
PodcastStoreError::NotSubscribed(_) => Self::new(409, error.to_string()),
|
||||
PodcastStoreError::Invalid(_) => Self::bad_request(error.to_string()),
|
||||
};
|
||||
}
|
||||
if let Some(SubscribeUrlError::Fetch(fetch)) = error.downcast_ref::<SubscribeUrlError>() {
|
||||
// The feed could not be used: the request cannot succeed as is.
|
||||
let status = match fetch.kind {
|
||||
FetchErrorKind::Timeout | FetchErrorKind::Transport => 502,
|
||||
_ => 422,
|
||||
};
|
||||
return Self::new(status, error.to_string());
|
||||
}
|
||||
tracing::warn!("podcast API request failed: {error:#}");
|
||||
Self::new(500, "internal error")
|
||||
}
|
||||
}
|
||||
|
||||
pub(crate) type ApiResult<T> = Result<T, ApiError>;
|
||||
|
||||
pub(crate) fn parse_podcast_id(value: &str) -> ApiResult<PodcastId> {
|
||||
PodcastId::parse(value).map_err(|_| ApiError::bad_request("invalid podcast id"))
|
||||
}
|
||||
|
||||
pub(crate) fn parse_episode_id(value: &str) -> ApiResult<EpisodeId> {
|
||||
EpisodeId::parse(value).map_err(|_| ApiError::bad_request("invalid episode id"))
|
||||
}
|
||||
|
||||
fn decode<T: serde::de::DeserializeOwned>(body: Value) -> ApiResult<T> {
|
||||
serde_json::from_value(body).map_err(|error| ApiError::bad_request(error.to_string()))
|
||||
}
|
||||
|
||||
fn status_name(status: ProgressStatus) -> &'static str {
|
||||
match status {
|
||||
ProgressStatus::NotStarted => "not_started",
|
||||
ProgressStatus::InProgress => "in_progress",
|
||||
ProgressStatus::Completed => "completed",
|
||||
}
|
||||
}
|
||||
|
||||
fn episode_type_name(kind: EpisodeType) -> &'static str {
|
||||
match kind {
|
||||
EpisodeType::Full => "full",
|
||||
EpisodeType::Trailer => "trailer",
|
||||
EpisodeType::Bonus => "bonus",
|
||||
}
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Views
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Local fetch state shown next to a podcast (never synced).
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub(crate) struct FetchView {
|
||||
pub(crate) checked_at_ms: Option<i64>,
|
||||
pub(crate) last_success_at_ms: Option<i64>,
|
||||
pub(crate) next_check_at_ms: Option<i64>,
|
||||
pub(crate) last_error: Option<String>,
|
||||
pub(crate) consecutive_failures: u32,
|
||||
}
|
||||
|
||||
impl From<FetchState> for FetchView {
|
||||
fn from(state: FetchState) -> Self {
|
||||
Self {
|
||||
checked_at_ms: state.checked_at_ms,
|
||||
last_success_at_ms: state.last_success_at_ms,
|
||||
next_check_at_ms: state.next_check_at_ms,
|
||||
last_error: state.last_error,
|
||||
consecutive_failures: state.consecutive_failures,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// A podcast with its personal state and counters.
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub(crate) struct PodcastView {
|
||||
pub(crate) podcast_id: String,
|
||||
/// URL this account fetches.
|
||||
pub(crate) feed_url: String,
|
||||
pub(crate) title: String,
|
||||
pub(crate) author: Option<String>,
|
||||
pub(crate) description: Option<String>,
|
||||
pub(crate) link: Option<String>,
|
||||
pub(crate) image_url: Option<String>,
|
||||
pub(crate) subscribed: bool,
|
||||
/// `effective_share` (publication is MR-W3; shown read-only).
|
||||
pub(crate) shared: bool,
|
||||
pub(crate) episode_count: u64,
|
||||
pub(crate) unplayed_count: u64,
|
||||
pub(crate) in_progress_count: u64,
|
||||
pub(crate) season_count: u64,
|
||||
pub(crate) latest_published_at_ms: Option<i64>,
|
||||
pub(crate) fetch: FetchView,
|
||||
}
|
||||
|
||||
impl PodcastView {
|
||||
fn new(summary: PodcastSummary, fetch: FetchState) -> Self {
|
||||
Self {
|
||||
podcast_id: summary.podcast_id.to_string(),
|
||||
feed_url: summary.meta.feed_url.to_string(),
|
||||
title: summary.meta.title,
|
||||
author: summary.meta.author,
|
||||
description: summary.meta.description,
|
||||
link: summary.meta.link,
|
||||
image_url: summary.meta.image_url,
|
||||
subscribed: summary.subscribed,
|
||||
shared: summary.shared,
|
||||
episode_count: summary.episode_count,
|
||||
unplayed_count: summary.unplayed_count,
|
||||
in_progress_count: summary.in_progress_count,
|
||||
season_count: summary.season_count,
|
||||
latest_published_at_ms: summary.latest_published_at_ms,
|
||||
fetch: fetch.into(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// One season group (`season: null` holds the episodes without a season).
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub(crate) struct SeasonView {
|
||||
pub(crate) season: Option<u32>,
|
||||
pub(crate) episode_count: u64,
|
||||
pub(crate) unplayed_count: u64,
|
||||
pub(crate) first_published_at_ms: Option<i64>,
|
||||
pub(crate) last_published_at_ms: Option<i64>,
|
||||
}
|
||||
|
||||
impl From<SeasonSummary> for SeasonView {
|
||||
fn from(season: SeasonSummary) -> Self {
|
||||
Self {
|
||||
season: season.season,
|
||||
episode_count: season.episode_count,
|
||||
unplayed_count: season.unplayed_count,
|
||||
first_published_at_ms: season.first_published_at_ms,
|
||||
last_published_at_ms: season.last_published_at_ms,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An episode with its progress and the queue item the player uses.
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub(crate) struct EpisodeView {
|
||||
pub(crate) episode_id: String,
|
||||
pub(crate) podcast_id: String,
|
||||
pub(crate) title: String,
|
||||
pub(crate) description: Option<String>,
|
||||
pub(crate) season: Option<u32>,
|
||||
pub(crate) episode_number: Option<u32>,
|
||||
pub(crate) episode_type: &'static str,
|
||||
pub(crate) published_at_ms: Option<i64>,
|
||||
pub(crate) duration_ms: Option<i64>,
|
||||
pub(crate) image_url: Option<String>,
|
||||
pub(crate) link: Option<String>,
|
||||
/// Whether the latest refresh listed the episode (older episodes stay).
|
||||
pub(crate) in_feed: bool,
|
||||
/// `not_started`, `in_progress` or `completed`.
|
||||
pub(crate) status: &'static str,
|
||||
/// Stored position of the progress register.
|
||||
pub(crate) position_ms: i64,
|
||||
/// Where ordinary Play resumes (`ProgressRecord::resume_position_ms`).
|
||||
pub(crate) resume_position_ms: i64,
|
||||
/// Distinct completed listening sessions.
|
||||
pub(crate) completed_count: u64,
|
||||
/// Browser queue item: `PlaybackSource::PodcastEpisode` with the
|
||||
/// self-contained reference (see `player::queue_items`).
|
||||
pub(crate) track: Value,
|
||||
}
|
||||
|
||||
/// The queue reference of a catalog episode, with the register generation
|
||||
/// as handoff hint.
|
||||
fn episode_ref(item: &EpisodeListItem, podcast: &PodcastMeta) -> PodcastEpisodeRef {
|
||||
let mut reference = item.episode.to_ref(podcast);
|
||||
reference.progress_generation = item.progress.as_ref().map(|record| record.generation);
|
||||
reference
|
||||
}
|
||||
|
||||
/// Browser queue item of an episode reference.
|
||||
pub(crate) fn episode_track_json(reference: PodcastEpisodeRef) -> Value {
|
||||
queue_items::external_track_json(&PlaybackTrack::podcast_episode(reference), 0, None)
|
||||
}
|
||||
|
||||
impl EpisodeView {
|
||||
fn new(item: EpisodeListItem, podcast: &PodcastMeta) -> Self {
|
||||
let track = episode_track_json(episode_ref(&item, podcast));
|
||||
let status = status_name(item.status());
|
||||
let resume_position_ms = item.resume_position_ms();
|
||||
let position_ms = item
|
||||
.progress
|
||||
.as_ref()
|
||||
.map_or(0, |progress| progress.position_ms);
|
||||
let episode = item.episode;
|
||||
Self {
|
||||
episode_id: episode.episode_id.to_string(),
|
||||
podcast_id: episode.podcast_id.to_string(),
|
||||
title: episode.title,
|
||||
description: episode.description,
|
||||
season: episode.season,
|
||||
episode_number: episode.episode_number,
|
||||
episode_type: episode_type_name(episode.episode_type),
|
||||
published_at_ms: episode.published_at_ms,
|
||||
duration_ms: episode.duration_ms,
|
||||
image_url: episode.image_url,
|
||||
link: episode.link,
|
||||
in_feed: item.in_feed,
|
||||
status,
|
||||
position_ms,
|
||||
resume_position_ms,
|
||||
completed_count: item.completed_count,
|
||||
track,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn podcast_view(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
podcast_id: &PodcastId,
|
||||
) -> ApiResult<PodcastView> {
|
||||
let summary = store
|
||||
.podcast(user_id, podcast_id)
|
||||
.await?
|
||||
.ok_or_else(|| ApiError::not_found("unknown podcast"))?;
|
||||
let fetch = store.fetch_state(user_id, podcast_id).await?;
|
||||
Ok(PodcastView::new(summary, fetch))
|
||||
}
|
||||
|
||||
async fn episode_view(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
episode_id: &EpisodeId,
|
||||
) -> ApiResult<EpisodeView> {
|
||||
let item = store
|
||||
.episode(user_id, episode_id)
|
||||
.await?
|
||||
.ok_or_else(|| ApiError::not_found("unknown episode"))?;
|
||||
let podcast = store
|
||||
.podcast(user_id, &item.episode.podcast_id)
|
||||
.await?
|
||||
.ok_or_else(|| ApiError::not_found("unknown podcast"))?;
|
||||
Ok(EpisodeView::new(item, &podcast.meta))
|
||||
}
|
||||
|
||||
async fn catalog_ref(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
episode_id: &EpisodeId,
|
||||
) -> ApiResult<PodcastEpisodeRef> {
|
||||
store
|
||||
.episode_ref(user_id, episode_id)
|
||||
.await?
|
||||
.ok_or_else(|| ApiError::not_found("unknown episode"))
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Podcasts
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) struct PodcastList {
|
||||
pub(crate) podcasts: Vec<PodcastView>,
|
||||
}
|
||||
|
||||
/// Podcasts of the account: subscribed ones, or with `all` also
|
||||
/// unsubscribed podcasts and podcasts only known from synced progress.
|
||||
pub(crate) async fn list_podcasts(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
all: bool,
|
||||
) -> ApiResult<PodcastList> {
|
||||
let filter = if all {
|
||||
PodcastListFilter::All
|
||||
} else {
|
||||
PodcastListFilter::Subscribed
|
||||
};
|
||||
let mut podcasts = Vec::new();
|
||||
for summary in store.list_podcasts(user_id, filter).await? {
|
||||
let fetch = store.fetch_state(user_id, &summary.podcast_id).await?;
|
||||
podcasts.push(PodcastView::new(summary, fetch));
|
||||
}
|
||||
Ok(PodcastList { podcasts })
|
||||
}
|
||||
|
||||
/// Listening sessions shown in a podcast's history.
|
||||
pub(crate) const DETAIL_HISTORY_LIMIT: usize = 20;
|
||||
|
||||
/// A listening session in the history (completed or at least 30 s).
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub(crate) struct HistoryView {
|
||||
pub(crate) episode_id: String,
|
||||
pub(crate) episode_title: Option<String>,
|
||||
pub(crate) started_at_ms: i64,
|
||||
pub(crate) ended_at_ms: i64,
|
||||
pub(crate) listened_ms: i64,
|
||||
pub(crate) completed: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) struct PodcastDetail {
|
||||
pub(crate) podcast: PodcastView,
|
||||
pub(crate) seasons: Vec<SeasonView>,
|
||||
/// Newest listening sessions of this podcast, from every device.
|
||||
pub(crate) history: Vec<HistoryView>,
|
||||
}
|
||||
|
||||
/// One podcast with its season groups.
|
||||
pub(crate) async fn podcast_detail(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
podcast_id: &PodcastId,
|
||||
) -> ApiResult<PodcastDetail> {
|
||||
let podcast = podcast_view(store, user_id, podcast_id).await?;
|
||||
let seasons = store
|
||||
.seasons(user_id, podcast_id)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(SeasonView::from)
|
||||
.collect();
|
||||
let history = store
|
||||
.listen_history(user_id, Some(podcast_id), DETAIL_HISTORY_LIMIT)
|
||||
.await?
|
||||
.into_iter()
|
||||
.map(|entry| HistoryView {
|
||||
episode_id: entry.session.episode_id.to_string(),
|
||||
episode_title: entry.episode_title,
|
||||
started_at_ms: entry.session.started_at_ms,
|
||||
ended_at_ms: entry.session.ended_at_ms,
|
||||
listened_ms: entry.session.listened_ms,
|
||||
completed: entry.session.completed,
|
||||
})
|
||||
.collect();
|
||||
Ok(PodcastDetail {
|
||||
podcast,
|
||||
seasons,
|
||||
history,
|
||||
})
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct SubscribeRequest {
|
||||
url: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) struct SubscribeResponse {
|
||||
pub(crate) podcast: PodcastView,
|
||||
pub(crate) already_subscribed: bool,
|
||||
pub(crate) new_episodes: usize,
|
||||
}
|
||||
|
||||
/// "Add RSS": `{ "url": "..." }`. The feed is fetched before anything is
|
||||
/// stored; the new subscription is private.
|
||||
pub(crate) async fn subscribe_url(
|
||||
store: &PodcastStore,
|
||||
fetcher: &FeedFetcher,
|
||||
user_id: i64,
|
||||
body: Value,
|
||||
now_ms: i64,
|
||||
) -> ApiResult<SubscribeResponse> {
|
||||
let request: SubscribeRequest = decode(body)?;
|
||||
let url = FeedUrl::from_user_input(&request.url)
|
||||
.map_err(|error| ApiError::bad_request(format!("invalid feed URL: {error}")))?;
|
||||
let subscription = runner::subscribe_url(store, fetcher, user_id, &url, now_ms).await?;
|
||||
Ok(SubscribeResponse {
|
||||
podcast: podcast_view(store, user_id, &subscription.podcast_id).await?,
|
||||
already_subscribed: subscription.already_subscribed,
|
||||
new_episodes: subscription.refresh.new_episodes,
|
||||
})
|
||||
}
|
||||
|
||||
/// Subscribes again to a known podcast with its stored channel metadata
|
||||
/// (progress and history continue). The refresh job fetches it on its next
|
||||
/// run.
|
||||
pub(crate) async fn resubscribe(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
podcast_id: &PodcastId,
|
||||
) -> ApiResult<PodcastView> {
|
||||
let summary = store
|
||||
.podcast(user_id, podcast_id)
|
||||
.await?
|
||||
.ok_or_else(|| ApiError::not_found("unknown podcast"))?;
|
||||
store.subscribe(user_id, &summary.meta).await?;
|
||||
podcast_view(store, user_id, podcast_id).await
|
||||
}
|
||||
|
||||
/// Unsubscribes: stops monitoring, revokes a publication, keeps progress
|
||||
/// and history.
|
||||
pub(crate) async fn unsubscribe(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
podcast_id: &PodcastId,
|
||||
) -> ApiResult<PodcastView> {
|
||||
if store.podcast(user_id, podcast_id).await?.is_none() {
|
||||
return Err(ApiError::not_found("unknown podcast"));
|
||||
}
|
||||
store.unsubscribe(user_id, podcast_id).await?;
|
||||
podcast_view(store, user_id, podcast_id).await
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Episodes
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Query string of the episode list.
|
||||
#[derive(Debug, Clone, Default, Deserialize)]
|
||||
pub(crate) struct EpisodeListParams {
|
||||
/// Season number, or `none` for the episodes without a season.
|
||||
#[serde(default)]
|
||||
pub(crate) season: Option<String>,
|
||||
/// `unplayed`, `not_started`, `in_progress` or `played`.
|
||||
#[serde(default)]
|
||||
pub(crate) played: Option<String>,
|
||||
/// Search text (titles and descriptions).
|
||||
#[serde(default)]
|
||||
pub(crate) q: Option<String>,
|
||||
/// `newest` (default), `oldest`, `number` or `number_desc`.
|
||||
#[serde(default)]
|
||||
pub(crate) sort: Option<String>,
|
||||
#[serde(default)]
|
||||
pub(crate) limit: Option<usize>,
|
||||
#[serde(default)]
|
||||
pub(crate) offset: Option<usize>,
|
||||
}
|
||||
|
||||
impl EpisodeListParams {
|
||||
/// The store query (one row more than the page, to tell whether more
|
||||
/// rows follow).
|
||||
pub(crate) fn query(&self, podcast_id: PodcastId) -> ApiResult<(EpisodeQuery, usize)> {
|
||||
let blank = |value: &Option<String>| {
|
||||
value
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|value| !value.is_empty())
|
||||
.map(str::to_string)
|
||||
};
|
||||
let season = match blank(&self.season).as_deref() {
|
||||
None | Some("all") => SeasonFilter::Any,
|
||||
Some("none") => SeasonFilter::NoSeason,
|
||||
Some(value) => SeasonFilter::Season(
|
||||
value
|
||||
.parse()
|
||||
.map_err(|_| ApiError::bad_request("invalid season"))?,
|
||||
),
|
||||
};
|
||||
let played = match blank(&self.played).as_deref() {
|
||||
None | Some("all") => PlayedFilter::Any,
|
||||
Some("unplayed") => PlayedFilter::Unplayed,
|
||||
Some("not_started") => PlayedFilter::NotStarted,
|
||||
Some("in_progress") => PlayedFilter::InProgress,
|
||||
Some("played") => PlayedFilter::Played,
|
||||
Some(_) => return Err(ApiError::bad_request("invalid played filter")),
|
||||
};
|
||||
let sort = match blank(&self.sort).as_deref() {
|
||||
None | Some("newest") => EpisodeSort::NewestFirst,
|
||||
Some("oldest") => EpisodeSort::OldestFirst,
|
||||
Some("number") => EpisodeSort::EpisodeNumber,
|
||||
Some("number_desc") => EpisodeSort::EpisodeNumberDesc,
|
||||
Some(_) => return Err(ApiError::bad_request("invalid sort")),
|
||||
};
|
||||
let limit = self
|
||||
.limit
|
||||
.unwrap_or(DEFAULT_EPISODE_PAGE)
|
||||
.clamp(1, MAX_EPISODE_PAGE);
|
||||
let mut query = EpisodeQuery::new(podcast_id);
|
||||
query.season = season;
|
||||
query.played = played;
|
||||
query.search = blank(&self.q);
|
||||
query.sort = sort;
|
||||
query.limit = Some(limit + 1);
|
||||
query.offset = self.offset.unwrap_or(0);
|
||||
Ok((query, limit))
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
pub(crate) struct EpisodePage {
|
||||
pub(crate) episodes: Vec<EpisodeView>,
|
||||
pub(crate) offset: usize,
|
||||
pub(crate) has_more: bool,
|
||||
}
|
||||
|
||||
/// A page of episodes of one podcast.
|
||||
pub(crate) async fn episodes(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
podcast_id: &PodcastId,
|
||||
params: &EpisodeListParams,
|
||||
) -> ApiResult<EpisodePage> {
|
||||
let podcast = store
|
||||
.podcast(user_id, podcast_id)
|
||||
.await?
|
||||
.ok_or_else(|| ApiError::not_found("unknown podcast"))?;
|
||||
let (query, limit) = params.query(podcast_id.clone())?;
|
||||
let mut rows = store.episodes(user_id, &query).await?;
|
||||
let has_more = rows.len() > limit;
|
||||
rows.truncate(limit);
|
||||
Ok(EpisodePage {
|
||||
episodes: rows
|
||||
.into_iter()
|
||||
.map(|item| EpisodeView::new(item, &podcast.meta))
|
||||
.collect(),
|
||||
offset: query.offset,
|
||||
has_more,
|
||||
})
|
||||
}
|
||||
|
||||
/// Explicit progress actions of the episode list.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub(crate) enum EpisodeAction {
|
||||
/// "Start over": position 0, in progress.
|
||||
Restart,
|
||||
/// "Played": completed, no listening session, no invented time.
|
||||
MarkPlayed,
|
||||
/// "Unplayed": not started at 0.
|
||||
MarkUnplayed,
|
||||
}
|
||||
|
||||
/// Runs an explicit progress action and returns the updated episode.
|
||||
pub(crate) async fn episode_action(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
episode_id: &EpisodeId,
|
||||
action: EpisodeAction,
|
||||
) -> ApiResult<EpisodeView> {
|
||||
let reference = catalog_ref(store, user_id, episode_id).await?;
|
||||
match action {
|
||||
EpisodeAction::Restart => {
|
||||
let session_id = format!("web-{}", uuid::Uuid::new_v4().simple());
|
||||
store.restart(user_id, &reference, &session_id).await?;
|
||||
}
|
||||
EpisodeAction::MarkPlayed => {
|
||||
store.mark_played(user_id, &reference).await?;
|
||||
}
|
||||
EpisodeAction::MarkUnplayed => {
|
||||
store.mark_unplayed(user_id, &reference).await?;
|
||||
}
|
||||
}
|
||||
episode_view(store, user_id, episode_id).await
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// Playback
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
/// Body of `POST /episodes/{id}/playback`.
|
||||
#[derive(Debug, Clone, Default, Deserialize)]
|
||||
pub(crate) struct PlaybackRequest {
|
||||
/// The queue item's reference. Used only when the catalog does not know
|
||||
/// the episode yet (an item received through a handoff); it is recorded
|
||||
/// like a reference learned through sync.
|
||||
#[serde(default)]
|
||||
pub(crate) episode: Option<PodcastEpisodeRef>,
|
||||
/// Start a listening session now (the browser is about to play).
|
||||
#[serde(default)]
|
||||
pub(crate) start: bool,
|
||||
/// Session id generated by the browser (required with `start`).
|
||||
#[serde(default)]
|
||||
pub(crate) session_id: Option<String>,
|
||||
/// Position to start at: a handoff or the user's choice. Without it the
|
||||
/// episode resumes from its progress register.
|
||||
#[serde(default)]
|
||||
pub(crate) position_ms: Option<i64>,
|
||||
/// `PodcastEpisodeRef::progress_generation` of a handed-off queue item.
|
||||
#[serde(default)]
|
||||
pub(crate) carried_generation: Option<u64>,
|
||||
}
|
||||
|
||||
/// How the browser plays an episode.
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub(crate) struct PlaybackResponse {
|
||||
pub(crate) episode_id: String,
|
||||
pub(crate) podcast_id: String,
|
||||
/// Session started by this request (`start`), with the generation its
|
||||
/// checkpoints use.
|
||||
pub(crate) session_id: Option<String>,
|
||||
pub(crate) generation: Option<u64>,
|
||||
/// Where to start.
|
||||
pub(crate) position_ms: i64,
|
||||
/// Register status before this request.
|
||||
pub(crate) status: &'static str,
|
||||
pub(crate) duration_ms: Option<i64>,
|
||||
/// Publisher URL (default: the browser streams it directly).
|
||||
pub(crate) direct_url: String,
|
||||
/// Same-origin proxy path when the administrator enabled the proxy.
|
||||
pub(crate) proxy_url: Option<String>,
|
||||
pub(crate) mime: Option<String>,
|
||||
}
|
||||
|
||||
/// Prepares an episode for the player and, with `start`, begins a session.
|
||||
pub(crate) async fn playback(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
episode_id: &EpisodeId,
|
||||
body: Value,
|
||||
proxy_enabled: bool,
|
||||
) -> ApiResult<PlaybackResponse> {
|
||||
let request: PlaybackRequest = decode(body)?;
|
||||
if store.episode_ref(user_id, episode_id).await?.is_none() {
|
||||
match request.episode.as_ref() {
|
||||
Some(reference) if reference.episode_id == *episode_id => {
|
||||
store.ensure_episode(user_id, reference).await?;
|
||||
}
|
||||
Some(_) => return Err(ApiError::bad_request("episode reference mismatch")),
|
||||
None => return Err(ApiError::not_found("unknown episode")),
|
||||
}
|
||||
}
|
||||
let reference = catalog_ref(store, user_id, episode_id).await?;
|
||||
let current = store.progress(user_id, episode_id).await?;
|
||||
let status = current
|
||||
.as_ref()
|
||||
.map_or(ProgressStatus::NotStarted, |record| record.status);
|
||||
let resume = current
|
||||
.as_ref()
|
||||
.map_or(0, ProgressRecord::resume_position_ms);
|
||||
let mut position_ms = request.position_ms.unwrap_or(resume).max(0);
|
||||
let (mut session_id, mut generation) = (None, None);
|
||||
if request.start {
|
||||
let id = request
|
||||
.session_id
|
||||
.as_deref()
|
||||
.map(str::trim)
|
||||
.filter(|id| !id.is_empty())
|
||||
.ok_or_else(|| ApiError::bad_request("session_id is required to start"))?;
|
||||
let write = store
|
||||
.start_session(
|
||||
user_id,
|
||||
&reference,
|
||||
id,
|
||||
position_ms,
|
||||
request.carried_generation,
|
||||
)
|
||||
.await?;
|
||||
position_ms = write.record.position_ms;
|
||||
session_id = Some(write.session.session_id);
|
||||
generation = Some(write.session.generation);
|
||||
}
|
||||
let (direct_url, mime) = store
|
||||
.audio_source(user_id, episode_id)
|
||||
.await?
|
||||
.ok_or_else(|| ApiError::not_found("unknown episode"))?;
|
||||
Ok(PlaybackResponse {
|
||||
episode_id: episode_id.to_string(),
|
||||
podcast_id: reference.podcast_id.to_string(),
|
||||
session_id,
|
||||
generation,
|
||||
position_ms,
|
||||
status: status_name(status),
|
||||
duration_ms: reference.duration_ms,
|
||||
direct_url,
|
||||
proxy_url: proxy_enabled.then(|| super::http::proxy_path(episode_id)),
|
||||
mime,
|
||||
})
|
||||
}
|
||||
|
||||
/// What the player reports in `POST /episodes/{id}/progress`.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize)]
|
||||
#[serde(rename_all = "snake_case")]
|
||||
pub(crate) enum ProgressEvent {
|
||||
/// Periodic save while playing (every 15–30 s).
|
||||
Checkpoint,
|
||||
/// The user paused.
|
||||
Pause,
|
||||
/// Playback stopped: another item, the page closed, the queue cleared.
|
||||
Stop,
|
||||
/// Playback moves to another device.
|
||||
Handoff,
|
||||
/// The user moved the position (explicit action).
|
||||
Seek,
|
||||
/// The audio reached the end of the stream.
|
||||
Ended,
|
||||
}
|
||||
|
||||
impl ProgressEvent {
|
||||
/// Whether the event ends a stretch of listening that belongs in the
|
||||
/// session record.
|
||||
fn records_session(self) -> bool {
|
||||
matches!(self, Self::Pause | Self::Stop | Self::Handoff | Self::Ended)
|
||||
}
|
||||
}
|
||||
|
||||
/// Body of `POST /episodes/{id}/progress`.
|
||||
#[derive(Debug, Clone, Deserialize)]
|
||||
pub(crate) struct ProgressRequest {
|
||||
pub(crate) session_id: String,
|
||||
/// Generation of the session's latest explicit action.
|
||||
pub(crate) generation: u64,
|
||||
pub(crate) event: ProgressEvent,
|
||||
pub(crate) position_ms: i64,
|
||||
/// Duration of the loaded audio, when the browser knows it.
|
||||
#[serde(default)]
|
||||
pub(crate) duration_ms: Option<i64>,
|
||||
/// Time actually listened in this session (seeks excluded).
|
||||
#[serde(default)]
|
||||
pub(crate) listened_ms: Option<i64>,
|
||||
/// When the session started (browser clock, unix ms).
|
||||
#[serde(default)]
|
||||
pub(crate) started_at_ms: Option<i64>,
|
||||
#[serde(default)]
|
||||
pub(crate) start_position_ms: Option<i64>,
|
||||
}
|
||||
|
||||
/// Result of a progress report.
|
||||
#[derive(Debug, Clone, Serialize)]
|
||||
pub(crate) struct ProgressResponse {
|
||||
/// `written`, `superseded` (another device or action took over: stop
|
||||
/// writing at this generation) or `already_completed`.
|
||||
pub(crate) outcome: &'static str,
|
||||
/// Generation to use for the next checkpoints of this session.
|
||||
pub(crate) generation: u64,
|
||||
/// Register after the report.
|
||||
pub(crate) status: &'static str,
|
||||
pub(crate) position_ms: i64,
|
||||
/// Whether this report completed the episode.
|
||||
pub(crate) completed: bool,
|
||||
/// Whether the listening session was recorded (or grew).
|
||||
pub(crate) session_recorded: bool,
|
||||
}
|
||||
|
||||
/// Stores a progress report of the player's current session.
|
||||
pub(crate) async fn progress(
|
||||
store: &PodcastStore,
|
||||
user_id: i64,
|
||||
episode_id: &EpisodeId,
|
||||
body: Value,
|
||||
now_ms: i64,
|
||||
) -> ApiResult<ProgressResponse> {
|
||||
let request: ProgressRequest = decode(body)?;
|
||||
let reference = catalog_ref(store, user_id, episode_id).await?;
|
||||
let position_ms = request.position_ms.max(0);
|
||||
let duration_ms = request
|
||||
.duration_ms
|
||||
.filter(|duration| *duration > 0)
|
||||
.or(reference.duration_ms);
|
||||
let session = ProgressSession {
|
||||
episode: reference.clone(),
|
||||
session_id: request.session_id.trim().to_string(),
|
||||
generation: request.generation,
|
||||
};
|
||||
let reached_end =
|
||||
request.event == ProgressEvent::Ended || reaches_completion(position_ms, duration_ms);
|
||||
let outcome = match request.event {
|
||||
ProgressEvent::Seek => {
|
||||
CheckpointOutcome::Written(Box::new(store.seek(user_id, &session, position_ms).await?))
|
||||
}
|
||||
_ if reached_end => {
|
||||
store
|
||||
.complete_if_current(user_id, &session, position_ms)
|
||||
.await?
|
||||
}
|
||||
_ => store.checkpoint(user_id, &session, position_ms).await?,
|
||||
};
|
||||
let (name, record, completed) = match &outcome {
|
||||
CheckpointOutcome::Written(write) => (
|
||||
"written",
|
||||
write.record.clone(),
|
||||
write.record.status == ProgressStatus::Completed && reached_end,
|
||||
),
|
||||
CheckpointOutcome::Superseded { current } => ("superseded", current.clone(), false),
|
||||
CheckpointOutcome::AlreadyCompleted { current } => {
|
||||
("already_completed", current.clone(), false)
|
||||
}
|
||||
};
|
||||
let mut session_recorded = false;
|
||||
if request.event.records_session()
|
||||
&& let Some(started_at_ms) = request.started_at_ms
|
||||
{
|
||||
let started_at_ms = started_at_ms.clamp(0, now_ms);
|
||||
let listened_ms = request
|
||||
.listened_ms
|
||||
.unwrap_or(0)
|
||||
.clamp(0, now_ms - started_at_ms);
|
||||
let listen = ListenSession {
|
||||
session_id: session.session_id.clone(),
|
||||
episode_id: episode_id.clone(),
|
||||
podcast_id: reference.podcast_id.clone(),
|
||||
device_id: devices::local_device_id(store.pool(), user_id).await?,
|
||||
started_at_ms,
|
||||
ended_at_ms: now_ms,
|
||||
start_position_ms: request.start_position_ms.unwrap_or(0).max(0),
|
||||
end_position_ms: position_ms,
|
||||
listened_ms,
|
||||
completed: reached_end,
|
||||
};
|
||||
session_recorded = store
|
||||
.record_listen_session(user_id, &listen, Some(&reference))
|
||||
.await?
|
||||
.is_some();
|
||||
}
|
||||
Ok(ProgressResponse {
|
||||
outcome: name,
|
||||
generation: record.generation,
|
||||
status: status_name(record.status),
|
||||
position_ms: record.position_ms,
|
||||
completed,
|
||||
session_recorded,
|
||||
})
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn podcast() -> PodcastId {
|
||||
PodcastId::from_feed_url(&FeedUrl::parse("https://podcasts.example/feed.xml").unwrap())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn episode_list_params_map_to_store_queries() {
|
||||
let (query, limit) = EpisodeListParams::default().query(podcast()).unwrap();
|
||||
assert_eq!(limit, DEFAULT_EPISODE_PAGE);
|
||||
assert_eq!(query.limit, Some(DEFAULT_EPISODE_PAGE + 1));
|
||||
assert_eq!(query.season, SeasonFilter::Any);
|
||||
assert_eq!(query.played, PlayedFilter::Any);
|
||||
assert_eq!(query.sort, EpisodeSort::NewestFirst);
|
||||
assert_eq!(query.search, None);
|
||||
|
||||
let params = EpisodeListParams {
|
||||
season: Some("3".into()),
|
||||
played: Some("in_progress".into()),
|
||||
q: Some(" interview ".into()),
|
||||
sort: Some("number_desc".into()),
|
||||
limit: Some(10_000),
|
||||
offset: Some(40),
|
||||
};
|
||||
let (query, limit) = params.query(podcast()).unwrap();
|
||||
assert_eq!(query.season, SeasonFilter::Season(3));
|
||||
assert_eq!(query.played, PlayedFilter::InProgress);
|
||||
assert_eq!(query.search.as_deref(), Some("interview"));
|
||||
assert_eq!(query.sort, EpisodeSort::EpisodeNumberDesc);
|
||||
assert_eq!(limit, MAX_EPISODE_PAGE);
|
||||
assert_eq!(query.offset, 40);
|
||||
|
||||
let none = EpisodeListParams {
|
||||
season: Some("none".into()),
|
||||
played: Some("played".into()),
|
||||
q: Some(" ".into()),
|
||||
sort: Some("oldest".into()),
|
||||
..Default::default()
|
||||
};
|
||||
let (query, _) = none.query(podcast()).unwrap();
|
||||
assert_eq!(query.season, SeasonFilter::NoSeason);
|
||||
assert_eq!(query.played, PlayedFilter::Played);
|
||||
assert_eq!(query.search, None, "blank search is no filter");
|
||||
assert_eq!(query.sort, EpisodeSort::OldestFirst);
|
||||
|
||||
for bad in [
|
||||
EpisodeListParams {
|
||||
season: Some("first".into()),
|
||||
..Default::default()
|
||||
},
|
||||
EpisodeListParams {
|
||||
played: Some("sometimes".into()),
|
||||
..Default::default()
|
||||
},
|
||||
EpisodeListParams {
|
||||
sort: Some("random".into()),
|
||||
..Default::default()
|
||||
},
|
||||
] {
|
||||
assert_eq!(bad.query(podcast()).unwrap_err().status, 400);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ids_and_bodies_are_validated_before_the_store() {
|
||||
assert_eq!(parse_podcast_id("nope").unwrap_err().status, 400);
|
||||
assert_eq!(parse_episode_id("pod1:abc").unwrap_err().status, 400);
|
||||
assert!(parse_podcast_id(podcast().as_str()).is_ok());
|
||||
let error = decode::<ProgressRequest>(serde_json::json!({
|
||||
"session_id": "s", "generation": 1, "event": "rewind", "position_ms": 0
|
||||
}))
|
||||
.unwrap_err();
|
||||
assert_eq!(error.status, 400);
|
||||
let request: ProgressRequest = decode(serde_json::json!({
|
||||
"session_id": "s", "generation": 3, "event": "handoff", "position_ms": 1200
|
||||
}))
|
||||
.unwrap();
|
||||
assert_eq!(request.event, ProgressEvent::Handoff);
|
||||
assert!(request.event.records_session());
|
||||
assert!(!ProgressEvent::Checkpoint.records_session());
|
||||
assert!(!ProgressEvent::Seek.records_session());
|
||||
// A malformed episode reference in a playback request is a 400.
|
||||
let error = decode::<PlaybackRequest>(serde_json::json!({
|
||||
"episode": { "episode_id": "not an id" }
|
||||
}))
|
||||
.unwrap_err();
|
||||
assert_eq!(error.status, 400);
|
||||
let empty: PlaybackRequest = decode(serde_json::json!({})).unwrap();
|
||||
assert!(!empty.start && empty.episode.is_none() && empty.position_ms.is_none());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn store_errors_map_to_http_statuses() {
|
||||
let unknown: ApiError =
|
||||
anyhow::Error::from(PodcastStoreError::UnknownPodcast(podcast())).into();
|
||||
assert_eq!(unknown.status, 404);
|
||||
let not_subscribed: ApiError =
|
||||
anyhow::Error::from(PodcastStoreError::NotSubscribed(podcast())).into();
|
||||
assert_eq!(not_subscribed.status, 409);
|
||||
let invalid: ApiError = super::super::invalid("bad").into();
|
||||
assert_eq!(invalid.status, 400);
|
||||
let refused: ApiError =
|
||||
anyhow::Error::from(SubscribeUrlError::Fetch(super::super::fetch::FetchError {
|
||||
kind: FetchErrorKind::Refused,
|
||||
message: "address 127.0.0.1 is not public".into(),
|
||||
retry_after: None,
|
||||
}))
|
||||
.into();
|
||||
assert_eq!(refused.status, 422);
|
||||
assert!(refused.message.contains("not public"));
|
||||
let timeout: ApiError =
|
||||
anyhow::Error::from(SubscribeUrlError::Fetch(super::super::fetch::FetchError {
|
||||
kind: FetchErrorKind::Timeout,
|
||||
message: "timed out".into(),
|
||||
retry_after: None,
|
||||
}))
|
||||
.into();
|
||||
assert_eq!(timeout.status, 502);
|
||||
let other: ApiError = anyhow::anyhow!("connection reset").into();
|
||||
assert_eq!(other.status, 500);
|
||||
assert_eq!(other.message, "internal error", "internals are not shown");
|
||||
}
|
||||
}
|
||||
@@ -844,6 +844,7 @@ impl PodcastStore {
|
||||
|
||||
/// A snapshot holding only this account's podcast sections, bounded
|
||||
/// with the default budget (`MAX_PODCAST_SNAPSHOT_BYTES`).
|
||||
#[cfg(test)]
|
||||
pub(crate) async fn export_snapshot(&self, user_id: i64) -> Result<SyncSnapshot> {
|
||||
let mut snapshot = SyncSnapshot::default();
|
||||
self.fill_snapshot(
|
||||
|
||||
+339
-2
@@ -1,7 +1,30 @@
|
||||
//! HTTP endpoints of the podcast runtime, mounted at `/api/podcasts`:
|
||||
//! HTTP endpoints of the podcast runtime, mounted at `/api/podcasts`. The
|
||||
//! request handling lives in [`super::api`]; this module authenticates (the
|
||||
//! session or a bearer token of the signed-in account) and maps results to
|
||||
//! JSON responses.
|
||||
//!
|
||||
//! Podcast UI:
|
||||
//!
|
||||
//! * `GET /feeds[?all=1]` — subscribed podcasts (with `all`, also
|
||||
//! unsubscribed ones and podcasts only known from synced progress), with
|
||||
//! counters and the local fetch state.
|
||||
//! * `POST /feeds` `{url}` — "add RSS": fetch, then subscribe (private).
|
||||
//! * `GET /feeds/{podcast_id}` — one podcast and its season groups.
|
||||
//! * `GET /feeds/{podcast_id}/episodes?season=&played=&q=&sort=&limit=&offset=`
|
||||
//! * `POST /feeds/{podcast_id}/subscribe`, `POST /feeds/{podcast_id}/unsubscribe`
|
||||
//! (unsubscribing keeps progress and history).
|
||||
//! * `POST /episodes/{episode_id}/restart|played|unplayed` — explicit
|
||||
//! progress actions.
|
||||
//! * `POST /{podcast_id}/refresh` — manual feed refresh of a subscribed
|
||||
//! podcast (ignores the failure backoff, at most every 30 s).
|
||||
//!
|
||||
//! Web player:
|
||||
//!
|
||||
//! * `POST /episodes/{episode_id}/playback` — audio source, resume position
|
||||
//! and (when playing starts) a new listening session.
|
||||
//! * `POST /episodes/{episode_id}/progress` — checkpoints, pause, seek,
|
||||
//! stop, handoff and end of stream of that session (also sent with
|
||||
//! `navigator.sendBeacon` when the page is hidden).
|
||||
//! * `GET /episodes/{episode_id}/source` — how the browser gets the audio:
|
||||
//! the publisher URL (default, the browser streams it directly) and the
|
||||
//! proxy URL when the administrator enabled the proxy.
|
||||
@@ -17,7 +40,7 @@ use cot::http::header::{
|
||||
ACCEPT_RANGES, CACHE_CONTROL, CONTENT_LENGTH, CONTENT_RANGE, CONTENT_TYPE, RANGE, RETRY_AFTER,
|
||||
};
|
||||
use cot::json::Json;
|
||||
use cot::request::extractors::Path;
|
||||
use cot::request::extractors::{Path, UrlQuery};
|
||||
use cot::response::IntoResponse;
|
||||
use cot::router::method::{get, post};
|
||||
use cot::router::{Route, Router};
|
||||
@@ -27,6 +50,7 @@ use futures_util::TryStreamExt;
|
||||
use music_dht::podcast::{EpisodeId, PodcastId};
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use super::api::{self, ApiError, EpisodeAction, EpisodeListParams};
|
||||
use super::fetch::FeedFetcher;
|
||||
use super::proxy::AudioProxy;
|
||||
use super::runner::{self, ManualRefreshError, TargetResult};
|
||||
@@ -48,6 +72,55 @@ fn internal(error: impl std::fmt::Display) -> cot::Error {
|
||||
cot::Error::internal(error.to_string())
|
||||
}
|
||||
|
||||
fn api_error(error: ApiError) -> cot::response::Response {
|
||||
json_error(
|
||||
StatusCode::from_u16(error.status).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR),
|
||||
&error.message,
|
||||
)
|
||||
}
|
||||
|
||||
/// JSON response of an [`api`] result; personal data is never cached.
|
||||
fn api_response<T: Serialize>(result: api::ApiResult<T>) -> cot::Result<cot::response::Response> {
|
||||
match result {
|
||||
Ok(value) => {
|
||||
let mut response = Json(value).into_response()?;
|
||||
response
|
||||
.headers_mut()
|
||||
.insert(CACHE_CONTROL, "private, no-store".parse().expect("static"));
|
||||
Ok(response)
|
||||
}
|
||||
Err(error) => Ok(api_error(error)),
|
||||
}
|
||||
}
|
||||
|
||||
/// The signed-in account, or the 401 response.
|
||||
async fn signed_in(
|
||||
auth_ctx: &auth::AuthContext,
|
||||
session: &Session,
|
||||
db: &Database,
|
||||
) -> Result<i64, cot::response::Response> {
|
||||
match auth::get_request_user(auth_ctx, session, db).await {
|
||||
Some(user) => Ok(user.id),
|
||||
None => Err(json_error(StatusCode::UNAUTHORIZED, "not authenticated")),
|
||||
}
|
||||
}
|
||||
|
||||
/// Largest JSON body accepted (a playback request carries one episode reference).
|
||||
const MAX_JSON_BODY: usize = 64 * 1024;
|
||||
|
||||
/// Request body as JSON (`null` when empty); malformed JSON is a 400.
|
||||
async fn json_body(request: cot::request::Request) -> Result<serde_json::Value, ApiError> {
|
||||
let bytes = request
|
||||
.into_body()
|
||||
.into_bytes_limited(MAX_JSON_BODY)
|
||||
.await
|
||||
.map_err(|error| ApiError::new(400, format!("unreadable body: {error}")))?;
|
||||
if bytes.iter().all(u8::is_ascii_whitespace) {
|
||||
return Ok(serde_json::Value::Object(Default::default()));
|
||||
}
|
||||
serde_json::from_slice(&bytes).map_err(|error| ApiError::new(400, error.to_string()))
|
||||
}
|
||||
|
||||
/// Shared state of the handlers.
|
||||
#[derive(Clone)]
|
||||
struct State {
|
||||
@@ -327,6 +400,163 @@ async fn audio_handler(
|
||||
builder.body(Body::streaming(body)).map_err(internal)
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
struct ListQuery {
|
||||
#[serde(default)]
|
||||
all: Option<String>,
|
||||
}
|
||||
|
||||
async fn list_handler(
|
||||
state: State,
|
||||
auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
query: UrlQuery<ListQuery>,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
let user_id = match signed_in(&auth_ctx, &session, &db).await {
|
||||
Ok(user_id) => user_id,
|
||||
Err(response) => return Ok(response),
|
||||
};
|
||||
let all = matches!(query.0.all.as_deref(), Some("1" | "true"));
|
||||
let store = state.store().await?;
|
||||
api_response(api::list_podcasts(&store, user_id, all).await)
|
||||
}
|
||||
|
||||
async fn subscribe_url_handler(
|
||||
state: State,
|
||||
auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
request: cot::request::Request,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
let user_id = match signed_in(&auth_ctx, &session, &db).await {
|
||||
Ok(user_id) => user_id,
|
||||
Err(response) => return Ok(response),
|
||||
};
|
||||
let body = match json_body(request).await {
|
||||
Ok(body) => body,
|
||||
Err(error) => return Ok(api_error(error)),
|
||||
};
|
||||
let store = state.store().await?;
|
||||
let fetcher = state.fetcher().await?;
|
||||
api_response(api::subscribe_url(&store, fetcher, user_id, body, now_ms()).await)
|
||||
}
|
||||
|
||||
/// What a `/feeds/{podcast_id}...` route does.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
enum PodcastRoute {
|
||||
Detail,
|
||||
Subscribe,
|
||||
Unsubscribe,
|
||||
}
|
||||
|
||||
async fn podcast_handler(
|
||||
state: State,
|
||||
route: PodcastRoute,
|
||||
auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
path: Path<PodcastPath>,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
let user_id = match signed_in(&auth_ctx, &session, &db).await {
|
||||
Ok(user_id) => user_id,
|
||||
Err(response) => return Ok(response),
|
||||
};
|
||||
let podcast_id = match api::parse_podcast_id(&path.0.podcast_id) {
|
||||
Ok(id) => id,
|
||||
Err(error) => return Ok(api_error(error)),
|
||||
};
|
||||
let store = state.store().await?;
|
||||
match route {
|
||||
PodcastRoute::Detail => {
|
||||
api_response(api::podcast_detail(&store, user_id, &podcast_id).await)
|
||||
}
|
||||
PodcastRoute::Subscribe => {
|
||||
api_response(api::resubscribe(&store, user_id, &podcast_id).await)
|
||||
}
|
||||
PodcastRoute::Unsubscribe => {
|
||||
api_response(api::unsubscribe(&store, user_id, &podcast_id).await)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn episodes_handler(
|
||||
state: State,
|
||||
auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
path: Path<PodcastPath>,
|
||||
query: UrlQuery<EpisodeListParams>,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
let user_id = match signed_in(&auth_ctx, &session, &db).await {
|
||||
Ok(user_id) => user_id,
|
||||
Err(response) => return Ok(response),
|
||||
};
|
||||
let podcast_id = match api::parse_podcast_id(&path.0.podcast_id) {
|
||||
Ok(id) => id,
|
||||
Err(error) => return Ok(api_error(error)),
|
||||
};
|
||||
let store = state.store().await?;
|
||||
api_response(api::episodes(&store, user_id, &podcast_id, &query.0).await)
|
||||
}
|
||||
|
||||
/// What a `/episodes/{episode_id}/...` POST route does.
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
enum EpisodeRoute {
|
||||
Action(EpisodeAction),
|
||||
Playback,
|
||||
Progress,
|
||||
}
|
||||
|
||||
async fn episode_handler(
|
||||
state: State,
|
||||
route: EpisodeRoute,
|
||||
auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
path: Path<EpisodePath>,
|
||||
request: cot::request::Request,
|
||||
) -> cot::Result<cot::response::Response> {
|
||||
let user_id = match signed_in(&auth_ctx, &session, &db).await {
|
||||
Ok(user_id) => user_id,
|
||||
Err(response) => return Ok(response),
|
||||
};
|
||||
let episode_id = match api::parse_episode_id(&path.0.episode_id) {
|
||||
Ok(id) => id,
|
||||
Err(error) => return Ok(api_error(error)),
|
||||
};
|
||||
let store = state.store().await?;
|
||||
match route {
|
||||
EpisodeRoute::Action(action) => {
|
||||
api_response(api::episode_action(&store, user_id, &episode_id, action).await)
|
||||
}
|
||||
EpisodeRoute::Playback => {
|
||||
let body = match json_body(request).await {
|
||||
Ok(body) => body,
|
||||
Err(error) => return Ok(api_error(error)),
|
||||
};
|
||||
let (config, _) = AppConfig::load_with_db(&db).await;
|
||||
api_response(
|
||||
api::playback(
|
||||
&store,
|
||||
user_id,
|
||||
&episode_id,
|
||||
body,
|
||||
config.podcast_audio_proxy_enabled,
|
||||
)
|
||||
.await,
|
||||
)
|
||||
}
|
||||
EpisodeRoute::Progress => {
|
||||
let body = match json_body(request).await {
|
||||
Ok(body) => body,
|
||||
Err(error) => return Ok(api_error(error)),
|
||||
};
|
||||
api_response(api::progress(&store, user_id, &episode_id, body, now_ms()).await)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl App for PodcastsApp {
|
||||
fn name(&self) -> &'static str {
|
||||
"podcasts"
|
||||
@@ -336,7 +566,114 @@ impl App for PodcastsApp {
|
||||
let refresh_state = self.state.clone();
|
||||
let source_state = self.state.clone();
|
||||
let audio_state = self.state.clone();
|
||||
let list_state = self.state.clone();
|
||||
let subscribe_state = self.state.clone();
|
||||
let episodes_state = self.state.clone();
|
||||
let podcast_route = |route: PodcastRoute| {
|
||||
let state = self.state.clone();
|
||||
move |auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
path: Path<PodcastPath>| {
|
||||
podcast_handler(state.clone(), route, auth_ctx, session, db, path)
|
||||
}
|
||||
};
|
||||
let episode_route = |route: EpisodeRoute| {
|
||||
let state = self.state.clone();
|
||||
move |auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
path: Path<EpisodePath>,
|
||||
request: cot::request::Request| {
|
||||
episode_handler(state.clone(), route, auth_ctx, session, db, path, request)
|
||||
}
|
||||
};
|
||||
// Routes are matched in order: literal prefixes come before
|
||||
// `/{podcast_id}/refresh`.
|
||||
Router::with_urls([
|
||||
Route::with_handler_and_name(
|
||||
"/feeds",
|
||||
get(
|
||||
move |auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
query: UrlQuery<ListQuery>| {
|
||||
list_handler(list_state.clone(), auth_ctx, session, db, query)
|
||||
},
|
||||
)
|
||||
.post(
|
||||
move |auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
request: cot::request::Request| {
|
||||
subscribe_url_handler(
|
||||
subscribe_state.clone(),
|
||||
auth_ctx,
|
||||
session,
|
||||
db,
|
||||
request,
|
||||
)
|
||||
},
|
||||
),
|
||||
"podcasts_feeds",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/feeds/{podcast_id}/episodes",
|
||||
get(
|
||||
move |auth_ctx: auth::AuthContext,
|
||||
session: Session,
|
||||
db: Database,
|
||||
path: Path<PodcastPath>,
|
||||
query: UrlQuery<EpisodeListParams>| {
|
||||
episodes_handler(episodes_state.clone(), auth_ctx, session, db, path, query)
|
||||
},
|
||||
),
|
||||
"podcasts_episodes",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/feeds/{podcast_id}/subscribe",
|
||||
post(podcast_route(PodcastRoute::Subscribe)),
|
||||
"podcasts_subscribe",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/feeds/{podcast_id}/unsubscribe",
|
||||
post(podcast_route(PodcastRoute::Unsubscribe)),
|
||||
"podcasts_unsubscribe",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/feeds/{podcast_id}",
|
||||
get(podcast_route(PodcastRoute::Detail)),
|
||||
"podcasts_detail",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/episodes/{episode_id}/playback",
|
||||
post(episode_route(EpisodeRoute::Playback)),
|
||||
"podcasts_episode_playback",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/episodes/{episode_id}/progress",
|
||||
post(episode_route(EpisodeRoute::Progress)),
|
||||
"podcasts_episode_progress",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/episodes/{episode_id}/restart",
|
||||
post(episode_route(EpisodeRoute::Action(EpisodeAction::Restart))),
|
||||
"podcasts_episode_restart",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/episodes/{episode_id}/played",
|
||||
post(episode_route(EpisodeRoute::Action(
|
||||
EpisodeAction::MarkPlayed,
|
||||
))),
|
||||
"podcasts_episode_played",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/episodes/{episode_id}/unplayed",
|
||||
post(episode_route(EpisodeRoute::Action(
|
||||
EpisodeAction::MarkUnplayed,
|
||||
))),
|
||||
"podcasts_episode_unplayed",
|
||||
),
|
||||
Route::with_handler_and_name(
|
||||
"/episodes/{episode_id}/source",
|
||||
get(
|
||||
|
||||
+13
-10
@@ -53,14 +53,12 @@
|
||||
//! * `proxy` and [`http`] — the optional audio proxy and the
|
||||
//! `/api/podcasts` endpoints. Audio is streamed from the publisher, never
|
||||
//! stored.
|
||||
|
||||
// The podcast UI and its HTTP API, which call the local actions and most
|
||||
// queries, land in the next commits of this series; until then only sync,
|
||||
// the refresh job, the proxy endpoints and the tests use the store. Remove
|
||||
// this allowance with them.
|
||||
#![allow(dead_code, unused_imports)]
|
||||
//! * [`api`] — what the endpoints of the podcast UI and the web player do
|
||||
//! (subscribe by URL, lists, explicit progress actions, playback sessions
|
||||
//! and progress reports), independent of HTTP.
|
||||
|
||||
mod actions;
|
||||
pub(crate) mod api;
|
||||
mod apply;
|
||||
mod fetch;
|
||||
pub(crate) mod http;
|
||||
@@ -94,12 +92,12 @@ use music_dht::podcast::{
|
||||
use sqlx::Row;
|
||||
use sqlx::postgres::PgRow;
|
||||
|
||||
pub(crate) use actions::{CheckpointOutcome, ProgressSession, ProgressWrite, SubscribeOutcome};
|
||||
pub(crate) use apply::{ApplyOutcome, SnapshotApplyStats};
|
||||
pub(crate) use actions::{CheckpointOutcome, ProgressSession};
|
||||
pub(crate) use apply::ApplyOutcome;
|
||||
pub(crate) use fetch::FeedFetcher;
|
||||
pub(crate) use queries::{
|
||||
EpisodeListItem, EpisodeQuery, EpisodeSort, PlayedFilter, PodcastListFilter,
|
||||
PodcastListenEntry, PodcastSummary, SeasonFilter, SeasonSummary,
|
||||
EpisodeListItem, EpisodeQuery, EpisodeSort, PlayedFilter, PodcastListFilter, PodcastSummary,
|
||||
SeasonFilter, SeasonSummary,
|
||||
};
|
||||
pub(crate) use refresh::{FeedRefresh, FetchState, RefreshOutcome};
|
||||
|
||||
@@ -151,6 +149,11 @@ impl PodcastStore {
|
||||
Self { pool }
|
||||
}
|
||||
|
||||
/// The pool the store runs on.
|
||||
pub(crate) fn pool(&self) -> &sqlx::PgPool {
|
||||
&self.pool
|
||||
}
|
||||
|
||||
/// Starts a write transaction holding the account's podcast lock.
|
||||
async fn begin_write(
|
||||
&self,
|
||||
|
||||
@@ -697,10 +697,13 @@ async fn postgres_podcast_local_actions_keep_progress_through_unsubscribe() {
|
||||
),
|
||||
(0, ProgressStatus::InProgress, 12)
|
||||
);
|
||||
let finished = store
|
||||
.complete_session(user_id, &restarted.session, 1_790_000)
|
||||
let CheckpointOutcome::Written(finished) = store
|
||||
.complete_if_current(user_id, &restarted.session, 1_790_000)
|
||||
.await
|
||||
.unwrap();
|
||||
.unwrap()
|
||||
else {
|
||||
panic!("the running session completes the episode");
|
||||
};
|
||||
assert_eq!(
|
||||
(finished.record.status, finished.record.generation),
|
||||
(ProgressStatus::Completed, 13)
|
||||
@@ -1725,3 +1728,450 @@ async fn postgres_podcast_refresh_job_schedules_backs_off_and_moves_feeds() {
|
||||
|
||||
cleanup(&pool, [a, b, c]).await;
|
||||
}
|
||||
|
||||
// ---------------------------------------------------------------------------
|
||||
// HTTP API of the podcast UI and the web player (`api`, behind `http`)
|
||||
// ---------------------------------------------------------------------------
|
||||
|
||||
async fn logged_kinds(pool: &sqlx::PgPool, user_id: i64) -> Vec<String> {
|
||||
sqlx::query_scalar("SELECT kind FROM furumusic__fed_sync_ops WHERE user_id = $1 ORDER BY seq")
|
||||
.bind(user_id)
|
||||
.fetch_all(pool)
|
||||
.await
|
||||
.unwrap()
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
#[ignore = "requires a disposable database in FURU_DEVICE_SYNC_TEST_DATABASE_URL"]
|
||||
async fn postgres_podcast_api_subscribes_plays_and_keeps_progress() {
|
||||
use super::api::{self, EpisodeAction, EpisodeListParams};
|
||||
use super::test_server::{Route, TestServer};
|
||||
use serde_json::json;
|
||||
|
||||
let pool = test_pool().await;
|
||||
let store = PodcastStore::new(pool.clone());
|
||||
let (user, other) = (random_user(), random_user());
|
||||
cleanup(&pool, [user, other]).await;
|
||||
let server = TestServer::start();
|
||||
let items = r#"
|
||||
<item><title>Pilot</title><guid>s1e1</guid><itunes:season>1</itunes:season>
|
||||
<itunes:episode>1</itunes:episode><itunes:duration>600</itunes:duration>
|
||||
<pubDate>Mon, 01 Jan 2024 10:00:00 GMT</pubDate><description>First interview</description>
|
||||
<enclosure url="/audio/s1e1.mp3" type="audio/mpeg" length="1000"/></item>
|
||||
<item><title>Bonus</title><guid>bonus</guid><itunes:duration>120</itunes:duration>
|
||||
<pubDate>Tue, 02 Jan 2024 10:00:00 GMT</pubDate>
|
||||
<enclosure url="/audio/bonus.mp3" type="audio/mpeg" length="1000"/></item>"#;
|
||||
server.set("/show.xml", Route::new(rss(items), "application/rss+xml"));
|
||||
server.set("/page.html", Route::new("<html></html>", "text/html"));
|
||||
server.set("/gone.xml", Route::new("gone", "text/plain").status(404));
|
||||
let fetcher = local_fetcher();
|
||||
let now = super::now_ms();
|
||||
|
||||
// "Add RSS": invalid input and unusable feeds subscribe nothing.
|
||||
for (body, status) in [
|
||||
(json!({}), 400),
|
||||
(json!({"url": "ftp://example.org/feed"}), 400),
|
||||
(json!({"url": server.url("/page.html")}), 422),
|
||||
(json!({"url": server.url("/gone.xml")}), 422),
|
||||
] {
|
||||
let error = api::subscribe_url(&store, &fetcher, user, body.clone(), now)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(error.status, status, "{body}: {}", error.message);
|
||||
}
|
||||
// The production policy never reaches the local server.
|
||||
let refused = api::subscribe_url(
|
||||
&store,
|
||||
&FeedFetcher::new().unwrap(),
|
||||
user,
|
||||
json!({"url": server.url("/show.xml")}),
|
||||
now,
|
||||
)
|
||||
.await
|
||||
.unwrap_err();
|
||||
assert_eq!(refused.status, 422, "{}", refused.message);
|
||||
assert!(logged_kinds(&pool, user).await.is_empty());
|
||||
assert_eq!(server.requests("/show.xml").len(), 0);
|
||||
|
||||
let added = api::subscribe_url(
|
||||
&store,
|
||||
&fetcher,
|
||||
user,
|
||||
json!({"url": format!(" {} ", server.url("/show.xml"))}),
|
||||
now,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(!added.already_subscribed);
|
||||
assert_eq!(added.new_episodes, 2);
|
||||
let podcast = added.podcast;
|
||||
assert!(podcast.subscribed);
|
||||
assert!(!podcast.shared, "a new subscription is private");
|
||||
assert_eq!((podcast.episode_count, podcast.unplayed_count), (2, 2));
|
||||
assert_eq!(podcast.title, "Refresh Show");
|
||||
assert!(podcast.fetch.last_success_at_ms.is_some());
|
||||
assert!(podcast.fetch.next_check_at_ms.unwrap() > now);
|
||||
let podcast_id = PodcastId::parse(&podcast.podcast_id).unwrap();
|
||||
assert_eq!(
|
||||
logged_kinds(&pool, user).await,
|
||||
["podcast_subscription_set"]
|
||||
);
|
||||
// Adding it again writes nothing.
|
||||
let again = api::subscribe_url(
|
||||
&store,
|
||||
&fetcher,
|
||||
user,
|
||||
json!({"url": server.url("/show.xml")}),
|
||||
now,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(again.already_subscribed);
|
||||
assert_eq!(again.podcast.podcast_id, podcast.podcast_id);
|
||||
assert_eq!(logged_kinds(&pool, user).await.len(), 1);
|
||||
|
||||
// Lists and details are per account.
|
||||
let list = api::list_podcasts(&store, user, false).await.unwrap();
|
||||
assert_eq!(list.podcasts.len(), 1);
|
||||
assert!(
|
||||
api::list_podcasts(&store, other, true)
|
||||
.await
|
||||
.unwrap()
|
||||
.podcasts
|
||||
.is_empty()
|
||||
);
|
||||
assert_eq!(
|
||||
api::podcast_detail(&store, other, &podcast_id)
|
||||
.await
|
||||
.unwrap_err()
|
||||
.status,
|
||||
404
|
||||
);
|
||||
let detail = api::podcast_detail(&store, user, &podcast_id)
|
||||
.await
|
||||
.unwrap();
|
||||
let seasons: Vec<Option<u32>> = detail.seasons.iter().map(|season| season.season).collect();
|
||||
assert_eq!(seasons, [Some(1), None]);
|
||||
assert!(detail.history.is_empty());
|
||||
|
||||
// Episodes: newest first, filters, search, paging, queue items.
|
||||
let page = api::episodes(&store, user, &podcast_id, &EpisodeListParams::default())
|
||||
.await
|
||||
.unwrap();
|
||||
let titles: Vec<&str> = page.episodes.iter().map(|e| e.title.as_str()).collect();
|
||||
assert_eq!(titles, ["Bonus", "Pilot"]);
|
||||
assert!(!page.has_more);
|
||||
let pilot = &page.episodes[1];
|
||||
assert_eq!((pilot.season, pilot.episode_number), (Some(1), Some(1)));
|
||||
assert_eq!(pilot.status, "not_started");
|
||||
assert_eq!(pilot.track["source"]["kind"], "podcast_episode");
|
||||
assert_eq!(
|
||||
pilot.track["source"]["episode_id"],
|
||||
pilot.episode_id.as_str()
|
||||
);
|
||||
assert_eq!(pilot.track["unavailable"], false);
|
||||
assert_eq!(pilot.track["title"], "Pilot");
|
||||
let first = api::episodes(
|
||||
&store,
|
||||
user,
|
||||
&podcast_id,
|
||||
&EpisodeListParams {
|
||||
limit: Some(1),
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!((first.episodes.len(), first.has_more), (1, true));
|
||||
let season = api::episodes(
|
||||
&store,
|
||||
user,
|
||||
&podcast_id,
|
||||
&EpisodeListParams {
|
||||
season: Some("none".into()),
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(season.episodes.len(), 1);
|
||||
assert_eq!(season.episodes[0].title, "Bonus");
|
||||
let found = api::episodes(
|
||||
&store,
|
||||
user,
|
||||
&podcast_id,
|
||||
&EpisodeListParams {
|
||||
q: Some("INTERVIEW".into()),
|
||||
..Default::default()
|
||||
},
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(found.episodes.len(), 1, "description search, any case");
|
||||
let episode_id = EpisodeId::parse(&pilot.episode_id).unwrap();
|
||||
|
||||
// Playback: the source and the resume position, without writing.
|
||||
let prepared = api::playback(&store, user, &episode_id, json!({}), false)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(prepared.direct_url, server.url("/audio/s1e1.mp3"));
|
||||
assert_eq!(prepared.proxy_url, None);
|
||||
assert_eq!((prepared.position_ms, prepared.generation), (0, None));
|
||||
assert_eq!(prepared.duration_ms, Some(600_000));
|
||||
let proxied = api::playback(&store, user, &episode_id, json!({}), true)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
proxied.proxy_url.as_deref(),
|
||||
Some(format!("/api/podcasts/episodes/{episode_id}/audio").as_str())
|
||||
);
|
||||
assert_eq!(logged_kinds(&pool, user).await.len(), 1);
|
||||
assert_eq!(
|
||||
api::playback(&store, user, &episode_id, json!({"start": true}), false)
|
||||
.await
|
||||
.unwrap_err()
|
||||
.status,
|
||||
400,
|
||||
"starting needs a session id"
|
||||
);
|
||||
|
||||
// Play starts a session (explicit generation 1).
|
||||
let started = api::playback(
|
||||
&store,
|
||||
user,
|
||||
&episode_id,
|
||||
json!({"start": true, "session_id": "web-s1"}),
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(started.session_id.as_deref(), Some("web-s1"));
|
||||
assert_eq!((started.generation, started.position_ms), (Some(1), 0));
|
||||
let report = |body: serde_json::Value| {
|
||||
let store = store.clone();
|
||||
let episode_id = episode_id.clone();
|
||||
async move { api::progress(&store, user, &episode_id, body, super::now_ms()).await }
|
||||
};
|
||||
let t0 = super::now_ms() - 120_000;
|
||||
let saved = report(json!({
|
||||
"session_id": "web-s1", "generation": 1, "event": "checkpoint", "position_ms": 60_000,
|
||||
"duration_ms": 600_000,
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(saved.outcome, saved.generation, saved.status),
|
||||
("written", 1, "in_progress")
|
||||
);
|
||||
assert!(
|
||||
!saved.session_recorded,
|
||||
"checkpoints do not record the session"
|
||||
);
|
||||
// Pause records the session (at least 30 s listened).
|
||||
let paused = report(json!({
|
||||
"session_id": "web-s1", "generation": 1, "event": "pause", "position_ms": 90_000,
|
||||
"listened_ms": 90_000, "started_at_ms": t0, "start_position_ms": 0,
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert!(paused.session_recorded);
|
||||
// Seeking back is an explicit action; a late checkpoint at the old
|
||||
// generation is superseded.
|
||||
let sought = report(json!({
|
||||
"session_id": "web-s1", "generation": 1, "event": "seek", "position_ms": 30_000,
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(sought.outcome, sought.generation, sought.position_ms),
|
||||
("written", 2, 30_000)
|
||||
);
|
||||
let late = report(json!({
|
||||
"session_id": "web-s1", "generation": 1, "event": "checkpoint", "position_ms": 95_000,
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(late.outcome, late.generation, late.position_ms),
|
||||
("superseded", 2, 30_000)
|
||||
);
|
||||
// Ordinary Play resumes from the register.
|
||||
let resumed = api::playback(&store, user, &episode_id, json!({}), false)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(resumed.position_ms, resumed.status),
|
||||
(30_000, "in_progress")
|
||||
);
|
||||
// Reaching the completion tail completes once, with the session.
|
||||
let near_end = report(json!({
|
||||
"session_id": "web-s1", "generation": 2, "event": "checkpoint", "position_ms": 590_000,
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(near_end.outcome, near_end.status, near_end.completed),
|
||||
("written", "completed", true)
|
||||
);
|
||||
assert_eq!(near_end.generation, 3);
|
||||
let ended = report(json!({
|
||||
"session_id": "web-s1", "generation": 3, "event": "ended", "position_ms": 600_000,
|
||||
"listened_ms": 400_000, "started_at_ms": t0, "start_position_ms": 0,
|
||||
}))
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(ended.outcome, "already_completed");
|
||||
assert!(
|
||||
ended.session_recorded,
|
||||
"the session grew and is now completed"
|
||||
);
|
||||
let item = store.episode(user, &episode_id).await.unwrap().unwrap();
|
||||
assert_eq!(item.completed_count, 1);
|
||||
// A completed episode plays from the start.
|
||||
let replay = api::playback(&store, user, &episode_id, json!({}), false)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!((replay.position_ms, replay.status), (0, "completed"));
|
||||
let history = api::podcast_detail(&store, user, &podcast_id)
|
||||
.await
|
||||
.unwrap()
|
||||
.history;
|
||||
assert_eq!(history.len(), 1);
|
||||
assert!(history[0].completed);
|
||||
assert_eq!(history[0].episode_title.as_deref(), Some("Pilot"));
|
||||
|
||||
// Explicit list actions.
|
||||
let restarted = api::episode_action(&store, user, &episode_id, EpisodeAction::Restart)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(restarted.status, restarted.position_ms),
|
||||
("in_progress", 0)
|
||||
);
|
||||
let played = api::episode_action(&store, user, &episode_id, EpisodeAction::MarkPlayed)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(played.status, "completed");
|
||||
assert_eq!(
|
||||
played.completed_count, 1,
|
||||
"marking played invents no session"
|
||||
);
|
||||
let unplayed = api::episode_action(&store, user, &episode_id, EpisodeAction::MarkUnplayed)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!((unplayed.status, unplayed.position_ms), ("not_started", 0));
|
||||
assert_eq!(
|
||||
api::episode_action(&store, other, &episode_id, EpisodeAction::MarkPlayed)
|
||||
.await
|
||||
.unwrap_err()
|
||||
.status,
|
||||
404
|
||||
);
|
||||
|
||||
// A handed-off queue item the catalog does not know yet: the reference
|
||||
// is recorded and the session starts above the carried generation.
|
||||
let mut handed = test_episode();
|
||||
handed.progress_generation = Some(9);
|
||||
let handed_id = handed.episode_id.clone();
|
||||
assert_eq!(
|
||||
api::playback(&store, user, &handed_id, json!({}), false)
|
||||
.await
|
||||
.unwrap_err()
|
||||
.status,
|
||||
404
|
||||
);
|
||||
let mut wrong = handed.clone();
|
||||
wrong.episode_id = episode_id.clone();
|
||||
assert_eq!(
|
||||
api::playback(&store, user, &handed_id, json!({"episode": wrong}), false)
|
||||
.await
|
||||
.unwrap_err()
|
||||
.status,
|
||||
400
|
||||
);
|
||||
let taken_over = api::playback(
|
||||
&store,
|
||||
user,
|
||||
&handed_id,
|
||||
json!({
|
||||
"episode": handed, "start": true, "session_id": "web-s2",
|
||||
"position_ms": 1_200_000, "carried_generation": 9,
|
||||
}),
|
||||
false,
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(taken_over.generation, taken_over.position_ms),
|
||||
(Some(10), 1_200_000)
|
||||
);
|
||||
assert_eq!(taken_over.direct_url, "https://cdn.example/ep42.mp3");
|
||||
let catalog = store.episode(user, &handed_id).await.unwrap().unwrap();
|
||||
assert!(!catalog.in_feed);
|
||||
// A handoff away writes a final checkpoint at the session generation.
|
||||
let away = api::progress(
|
||||
&store,
|
||||
user,
|
||||
&handed_id,
|
||||
json!({
|
||||
"session_id": "web-s2", "generation": 10, "event": "handoff",
|
||||
"position_ms": 1_260_000, "listened_ms": 10_000,
|
||||
"started_at_ms": super::now_ms() - 60_000, "start_position_ms": 1_200_000,
|
||||
}),
|
||||
super::now_ms(),
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
(away.outcome, away.generation, away.position_ms),
|
||||
("written", 10, 1_260_000)
|
||||
);
|
||||
assert!(
|
||||
!away.session_recorded,
|
||||
"10 s is below the history threshold"
|
||||
);
|
||||
|
||||
// Unsubscribing keeps progress and history; subscribing again continues.
|
||||
let left = api::unsubscribe(&store, user, &podcast_id).await.unwrap();
|
||||
assert!(!left.subscribed);
|
||||
assert!(
|
||||
api::list_podcasts(&store, user, false)
|
||||
.await
|
||||
.unwrap()
|
||||
.podcasts
|
||||
.is_empty()
|
||||
);
|
||||
let all = api::list_podcasts(&store, user, true).await.unwrap();
|
||||
assert!(
|
||||
all.podcasts
|
||||
.iter()
|
||||
.any(|p| p.podcast_id == podcast.podcast_id)
|
||||
);
|
||||
let kept = store.episode(user, &episode_id).await.unwrap().unwrap();
|
||||
assert_eq!(kept.completed_count, 1);
|
||||
let back = api::resubscribe(&store, user, &podcast_id).await.unwrap();
|
||||
assert!(back.subscribed);
|
||||
assert_eq!(
|
||||
api::unsubscribe(&store, other, &podcast_id)
|
||||
.await
|
||||
.unwrap_err()
|
||||
.status,
|
||||
404
|
||||
);
|
||||
|
||||
// Every write went through the sync log, with its own operation kinds.
|
||||
let kinds = logged_kinds(&pool, user).await;
|
||||
let count = |kind: &str| kinds.iter().filter(|k| k.as_str() == kind).count();
|
||||
assert_eq!(count("podcast_subscription_set"), 3);
|
||||
assert_eq!(
|
||||
count("podcast_share_set"),
|
||||
1,
|
||||
"unsubscribing revokes sharing"
|
||||
);
|
||||
assert_eq!(count("podcast_listen_recorded"), 2);
|
||||
// start, checkpoint, pause, seek, completion, restart, played,
|
||||
// unplayed, handed-off start, handoff checkpoint
|
||||
assert_eq!(count("podcast_progress_set"), 10);
|
||||
|
||||
cleanup(&pool, [user, other]).await;
|
||||
}
|
||||
@@ -2,8 +2,8 @@
|
||||
|
||||
use anyhow::Result;
|
||||
use music_dht::podcast::{
|
||||
EpisodeId, EpisodeMeta, EpisodeType, FeedUrl, ListenSession, PodcastEpisodeRef, PodcastId,
|
||||
PodcastMeta, ProgressRecord, ProgressStatus, ShareRecord, SubscriptionRecord, effective_share,
|
||||
EpisodeId, EpisodeMeta, EpisodeType, ListenSession, PodcastEpisodeRef, PodcastId, PodcastMeta,
|
||||
ProgressRecord, ProgressStatus, SubscriptionRecord, effective_share,
|
||||
};
|
||||
use sqlx::postgres::PgRow;
|
||||
use sqlx::{PgConnection, Postgres, QueryBuilder, Row};
|
||||
@@ -441,21 +441,23 @@ impl PodcastStore {
|
||||
}
|
||||
|
||||
/// The share register, if any.
|
||||
#[cfg(test)]
|
||||
pub(crate) async fn share(
|
||||
&self,
|
||||
user_id: i64,
|
||||
podcast_id: &PodcastId,
|
||||
) -> Result<Option<ShareRecord>> {
|
||||
) -> Result<Option<music_dht::podcast::ShareRecord>> {
|
||||
let mut conn = self.pool.acquire().await?;
|
||||
apply::load_share(&mut conn, user_id, podcast_id).await
|
||||
}
|
||||
|
||||
/// The bounded, synced feed alias set of a podcast.
|
||||
#[cfg(test)]
|
||||
pub(crate) async fn feed_aliases(
|
||||
&self,
|
||||
user_id: i64,
|
||||
podcast_id: &PodcastId,
|
||||
) -> Result<Vec<FeedUrl>> {
|
||||
) -> Result<Vec<music_dht::podcast::FeedUrl>> {
|
||||
let mut conn = self.pool.acquire().await?;
|
||||
apply::load_aliases(&mut conn, user_id, podcast_id).await
|
||||
}
|
||||
@@ -597,6 +599,7 @@ impl PodcastStore {
|
||||
|
||||
/// Position ordinary Play resumes from
|
||||
/// (`ProgressRecord::resume_position_ms`, 0 without progress).
|
||||
#[cfg(test)]
|
||||
pub(crate) async fn resume_position_ms(
|
||||
&self,
|
||||
user_id: i64,
|
||||
@@ -646,6 +649,7 @@ impl PodcastStore {
|
||||
}
|
||||
|
||||
/// Number of distinct completed sessions of an episode.
|
||||
#[cfg(test)]
|
||||
pub(crate) async fn completed_listen_count(
|
||||
&self,
|
||||
user_id: i64,
|
||||
|
||||
@@ -420,6 +420,9 @@ impl PodcastStore {
|
||||
}
|
||||
|
||||
/// Records the locally cached cover image of a podcast.
|
||||
// Covers are not cached yet: the browser loads `image_url` from the
|
||||
// publisher. The column and this setter stay for a later cache.
|
||||
#[cfg(test)]
|
||||
pub(crate) async fn set_cover_cache(
|
||||
&self,
|
||||
user_id: i64,
|
||||
|
||||
@@ -386,3 +386,77 @@ pub(crate) async fn refresh_now(
|
||||
let mut results = refresh_group(store, fetcher, &feed_url, vec![target], now_ms).await?;
|
||||
Ok(results.pop().map(|(_, result)| result).expect("one target"))
|
||||
}
|
||||
|
||||
/// Result of [`subscribe_url`].
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub(crate) struct UrlSubscription {
|
||||
/// Podcast the URL resolved to (an existing one for a known URL or alias).
|
||||
pub(crate) podcast_id: PodcastId,
|
||||
/// The account was already subscribed; no subscription was written.
|
||||
pub(crate) already_subscribed: bool,
|
||||
/// Ingestion of the document fetched for the subscription.
|
||||
pub(crate) refresh: RefreshOutcome,
|
||||
}
|
||||
|
||||
/// Why [`subscribe_url`] did not subscribe.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub(crate) enum SubscribeUrlError {
|
||||
/// The feed could not be fetched or parsed; nothing was stored.
|
||||
Fetch(FetchError),
|
||||
}
|
||||
|
||||
impl fmt::Display for SubscribeUrlError {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
match self {
|
||||
Self::Fetch(error) => write!(f, "the feed could not be loaded: {}", error.message),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl std::error::Error for SubscribeUrlError {}
|
||||
|
||||
/// Subscribes an account to the feed at `url` (the "add RSS" action).
|
||||
///
|
||||
/// The feed is fetched first: an address that is not public, a document
|
||||
/// that is not a feed or a failed request subscribes nothing
|
||||
/// ([`SubscribeUrlError`] inside the error). Then the subscription is
|
||||
/// written with the channel metadata of the document
|
||||
/// ([`PodcastStore::subscribe`]: a known URL or alias reuses the existing
|
||||
/// podcast, its progress and history; an active subscription writes
|
||||
/// nothing) and the document is ingested like a scheduled refresh, which
|
||||
/// also stores the validators and the next check.
|
||||
pub(crate) async fn subscribe_url(
|
||||
store: &PodcastStore,
|
||||
fetcher: &FeedFetcher,
|
||||
user_id: i64,
|
||||
url: &FeedUrl,
|
||||
now_ms: i64,
|
||||
) -> Result<UrlSubscription> {
|
||||
let document = match fetcher.fetch(url, &Validators::default()).await {
|
||||
Ok(FeedFetch::Fetched(document)) => document,
|
||||
Ok(FeedFetch::NotModified) => {
|
||||
// Unconditional requests are never answered with 304 by a
|
||||
// conforming server; refuse instead of subscribing blindly.
|
||||
return Err(SubscribeUrlError::Fetch(FetchError {
|
||||
kind: super::fetch::FetchErrorKind::Status(304),
|
||||
message: "unexpected 304 Not Modified".to_string(),
|
||||
retry_after: None,
|
||||
})
|
||||
.into());
|
||||
}
|
||||
Err(error) => return Err(SubscribeUrlError::Fetch(error).into()),
|
||||
};
|
||||
let subscription = store
|
||||
.subscribe(user_id, &document.feed.to_podcast_meta(url.clone()))
|
||||
.await?;
|
||||
let target = RefreshTarget {
|
||||
user_id,
|
||||
podcast_id: subscription.podcast_id.clone(),
|
||||
};
|
||||
let refresh = ingest(store, &target, &document, now_ms).await?;
|
||||
Ok(UrlSubscription {
|
||||
podcast_id: subscription.podcast_id,
|
||||
already_subscribed: subscription.already_subscribed,
|
||||
refresh,
|
||||
})
|
||||
}
|
||||
@@ -139,10 +139,6 @@ impl TestServer {
|
||||
TestServer { port, state }
|
||||
}
|
||||
|
||||
pub(crate) fn port(&self) -> u16 {
|
||||
self.port
|
||||
}
|
||||
|
||||
/// `http://127.0.0.1:<port><path>`.
|
||||
pub(crate) fn url(&self, path: &str) -> String {
|
||||
format!("http://127.0.0.1:{}{path}", self.port)
|
||||
|
||||
Reference in new issue
Block a user