Miguel Palhas
4d5cc120d1
DESIGN.md §9.6 now puts the current season at the top: seasons descend by number within a series (season 0 lands last under plain numeric descending) and episodes descend within each season. Changed the two queries in load_seasons; the SPA renders this order as given. arr-compat checked and untouched: it reads seasons with its own ORDER BY number query straight from the database, never through arr-api, and SeasonResource carries season_number, which Jellyseerr matches on rather than position. Sonarr's real API also returns seasons ascending, so the shim keeps the contract it emulates. The existing vanished-flag test indexed seasons positionally; it now looks them up by number so it tests the flag, not the order. New test asserts [2, 1, 0] for seasons and descending episodes within each. .sqlx regenerated via just db-prepare. just ci green locally.
2399 lines
90 KiB
Rust
2399 lines
90 KiB
Rust
//! The TV side of the library API. See DESIGN.md §4, §4.1 and §4.2.
|
|
//!
|
|
//! Nothing here is generic over media kind (§11): movies are concrete in
|
|
//! `movies.rs` and series are concrete here. What the two do share is the
|
|
//! policy loader, the release table and the owner tags, which already exist.
|
|
//!
|
|
//! Two rules shape the endpoints:
|
|
//!
|
|
//! - **Intent lives at the leaf** (§4.1). `wanted` is set on an episode.
|
|
//! `auto_track` on the series and `tracked` on the season are rules that
|
|
//! decide what happens to episodes a metadata refresh reveals; neither is
|
|
//! intent, and neither is read to answer "is this wanted".
|
|
//! - **Status is derived, never stored** (§4.2). Every series the API returns
|
|
//! carries a status computed from its episodes at request time.
|
|
|
|
use std::collections::HashMap;
|
|
use std::time::{Duration, SystemTime, UNIX_EPOCH};
|
|
|
|
use arr_core::tracking::{apply_auto_track, RefreshedSeason};
|
|
use arr_core::{
|
|
derive_series_status, EpisodeId, Language, MediaState, RootId, SeasonId, SeriesId,
|
|
SeriesStatus, TitleOverrides,
|
|
};
|
|
use arr_db::policy::language;
|
|
use axum::extract::{Path, Query, State};
|
|
use axum::http::StatusCode;
|
|
use axum::Json;
|
|
use chrono::{DateTime, NaiveDate, NaiveTime, Utc};
|
|
use serde::{Deserialize, Serialize};
|
|
use utoipa::{IntoParams, ToSchema};
|
|
|
|
use crate::movies::{pool, rescore, Accepted, ApiError, ErrorBody, Release};
|
|
use crate::owners::Owner;
|
|
use crate::search::tmdb_client;
|
|
use crate::state::{AppState, EpisodeCommand, SeasonCommand};
|
|
|
|
/// A series with the status derived from its episodes (§4.2).
|
|
#[derive(Debug, Clone, Serialize, ToSchema)]
|
|
pub struct Series {
|
|
pub id: i64,
|
|
pub tmdb_id: i64,
|
|
/// The Torznab `tvdbid` (§6.1), when TMDB knows one. Null means indexer
|
|
/// searches fall back to the title text query.
|
|
pub tvdb_id: Option<i64>,
|
|
pub title: String,
|
|
pub year: Option<i64>,
|
|
pub original_language: Option<String>,
|
|
pub root_id: i64,
|
|
/// §4.1. A rule about seasons metadata reveals, not intent.
|
|
pub auto_track: bool,
|
|
pub overrides: serde_json::Value,
|
|
/// Whether the show finished upstream, which `ended` is derived from.
|
|
pub upstream_ended: bool,
|
|
pub blocked: bool,
|
|
/// Path fragment, not a URL; stored at add time and refreshed with
|
|
/// metadata (#145), so pure-SQL views never need TMDB (§9.6).
|
|
pub poster_path: Option<String>,
|
|
/// TMDB's rating, out of 10; `null` when TMDB has no votes for it.
|
|
pub vote_average: Option<f64>,
|
|
/// `airing`, `incomplete`, `waiting`, `complete` or `ended` (§4.2).
|
|
pub status: String,
|
|
/// Episodes currently marked wanted (§4.1 — the only intent).
|
|
pub wanted_episodes: i64,
|
|
/// Wanted episodes already on disk.
|
|
pub available_episodes: i64,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, ToSchema)]
|
|
pub struct CreateSeries {
|
|
pub tmdb_id: i64,
|
|
pub title: String,
|
|
pub year: Option<i64>,
|
|
pub original_language: Option<String>,
|
|
pub root_id: i64,
|
|
#[serde(default)]
|
|
pub auto_track: bool,
|
|
#[serde(default)]
|
|
pub blocked: bool,
|
|
#[serde(default)]
|
|
pub upstream_ended: bool,
|
|
#[serde(default = "empty_overrides")]
|
|
pub overrides: serde_json::Value,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, ToSchema)]
|
|
pub struct UpdateSeries {
|
|
pub title: Option<String>,
|
|
pub year: Option<Option<i64>>,
|
|
pub original_language: Option<Option<String>>,
|
|
pub root_id: Option<i64>,
|
|
pub auto_track: Option<bool>,
|
|
pub blocked: Option<bool>,
|
|
pub upstream_ended: Option<bool>,
|
|
pub overrides: Option<serde_json::Value>,
|
|
}
|
|
|
|
/// A season and every episode in it, which is how the UI reads it.
|
|
#[derive(Debug, Clone, Serialize, ToSchema)]
|
|
pub struct Season {
|
|
pub id: i64,
|
|
pub series_id: i64,
|
|
pub number: i64,
|
|
/// §4.1. Whether new episodes of this season arrive wanted.
|
|
pub tracked: bool,
|
|
/// #141. The season vanished upstream while files remained under it,
|
|
/// which is why the row still exists. A conflict for the operator to
|
|
/// resolve; nothing was deleted from disk.
|
|
pub vanished: bool,
|
|
pub episodes: Vec<Episode>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, ToSchema)]
|
|
pub struct Episode {
|
|
pub id: i64,
|
|
/// The owning series — the episode deck route needs it without walking
|
|
/// seasons first.
|
|
pub series_id: i64,
|
|
pub season_id: i64,
|
|
pub season_number: i64,
|
|
pub number: i64,
|
|
pub title: String,
|
|
pub air_date: Option<String>,
|
|
/// §4.1. The only intent in the TV aggregate.
|
|
pub wanted: bool,
|
|
pub state: String,
|
|
/// #122. The episode vanished upstream while a file of its own remained,
|
|
/// which is why the row still exists. A conflict for the operator to
|
|
/// resolve; nothing was deleted from disk.
|
|
pub vanished: bool,
|
|
pub search_attempts: i64,
|
|
pub last_searched_at: Option<String>,
|
|
}
|
|
|
|
/// A season revealed by metadata, with the episodes it holds.
|
|
///
|
|
/// The series' `auto_track` decides whether those episodes arrive wanted
|
|
/// (§4.1); the request never says so directly.
|
|
#[derive(Debug, Deserialize, ToSchema)]
|
|
pub struct CreateSeason {
|
|
pub number: i64,
|
|
#[serde(default)]
|
|
pub episodes: Vec<CreateEpisode>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, ToSchema)]
|
|
pub struct CreateEpisode {
|
|
pub number: i64,
|
|
pub title: String,
|
|
/// ISO-8601 date, as TMDB gives it.
|
|
pub air_date: Option<String>,
|
|
}
|
|
|
|
/// Both fields of a season a person can set by hand.
|
|
///
|
|
/// Turning `tracked` on marks every already-revealed episode wanted, and
|
|
/// episodes revealed later follow while it stays on; turning it off withdraws
|
|
/// nothing (§4.1). `wanted` is the one-click "grab this season", and writes
|
|
/// intent onto every episode already in it — the two are deliberately
|
|
/// separate (§4.1).
|
|
#[derive(Debug, Deserialize, ToSchema)]
|
|
pub struct UpdateSeason {
|
|
pub tracked: Option<bool>,
|
|
pub wanted: Option<bool>,
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, ToSchema)]
|
|
pub struct UpdateEpisode {
|
|
pub wanted: Option<bool>,
|
|
}
|
|
|
|
fn empty_overrides() -> serde_json::Value {
|
|
serde_json::json!({})
|
|
}
|
|
|
|
fn validate_overrides(value: &serde_json::Value) -> Result<(), ApiError> {
|
|
let Some(object) = value.as_object() else {
|
|
return Err(ApiError::Invalid("overrides must be an object".into()));
|
|
};
|
|
if object
|
|
.keys()
|
|
.any(|key| key != "only_4k" && key != "allow_english_audio")
|
|
{
|
|
return Err(ApiError::Invalid(
|
|
"overrides supports only only_4k and allow_english_audio".into(),
|
|
));
|
|
}
|
|
if object.values().any(|value| !value.is_boolean()) {
|
|
return Err(ApiError::Invalid("override values must be booleans".into()));
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
/// The stored columns, before the derived status is attached.
|
|
struct SeriesRow {
|
|
id: i64,
|
|
tmdb_id: i64,
|
|
tvdb_id: Option<i64>,
|
|
title: String,
|
|
year: Option<i64>,
|
|
original_language: Option<String>,
|
|
root_id: i64,
|
|
auto_track: bool,
|
|
overrides: serde_json::Value,
|
|
upstream_ended: bool,
|
|
blocked: bool,
|
|
/// Stored at add time and refreshed with metadata (#145), so pure-SQL
|
|
/// views never need TMDB (§9.6).
|
|
poster_path: Option<String>,
|
|
/// TMDB's rating, out of 10; `null` when TMDB has no votes for it.
|
|
vote_average: Option<f64>,
|
|
/// NULL until a metadata refresh has stamped it (#160): the fact the
|
|
/// auto-track rule needs to tell a seeding refresh from a later one.
|
|
metadata_refreshed_at: Option<String>,
|
|
}
|
|
|
|
struct EpisodeRow {
|
|
series_id: i64,
|
|
id: i64,
|
|
season_id: i64,
|
|
season_number: i64,
|
|
number: i64,
|
|
title: String,
|
|
air_date: Option<String>,
|
|
wanted: bool,
|
|
state: String,
|
|
vanished: bool,
|
|
search_attempts: i64,
|
|
last_searched_at: Option<String>,
|
|
}
|
|
|
|
fn media_state(value: &str) -> MediaState {
|
|
match value {
|
|
"downloading" => MediaState::Downloading,
|
|
"available" => MediaState::Available,
|
|
_ => MediaState::Missing,
|
|
}
|
|
}
|
|
|
|
/// An `air_date` as TMDB writes it, or as a full timestamp if one ever
|
|
/// arrives that way. Anything else is treated as unknown, which §4.2 already
|
|
/// has a meaning for: it cannot pull a series into `airing`.
|
|
fn air_date(value: Option<&str>) -> Option<SystemTime> {
|
|
let value = value?;
|
|
let timestamp = if let Ok(date) = value.parse::<NaiveDate>() {
|
|
date.and_time(NaiveTime::MIN).and_utc().timestamp()
|
|
} else {
|
|
value.parse::<DateTime<Utc>>().ok()?.timestamp()
|
|
};
|
|
let seconds = u64::try_from(timestamp.abs()).ok()?;
|
|
if timestamp < 0 {
|
|
UNIX_EPOCH.checked_sub(Duration::from_secs(seconds))
|
|
} else {
|
|
UNIX_EPOCH.checked_add(Duration::from_secs(seconds))
|
|
}
|
|
}
|
|
|
|
fn core_series(row: &SeriesRow) -> arr_core::Series {
|
|
arr_core::Series {
|
|
id: SeriesId(row.id),
|
|
tmdb_id: u64::try_from(row.tmdb_id).unwrap_or_default(),
|
|
title: row.title.clone(),
|
|
year: row
|
|
.year
|
|
.and_then(|year| u16::try_from(year).ok())
|
|
.unwrap_or_default(),
|
|
original_language: row
|
|
.original_language
|
|
.as_deref()
|
|
.map_or(Language::Other(String::new()), language),
|
|
root_id: RootId(row.root_id),
|
|
auto_track: row.auto_track,
|
|
overrides: TitleOverrides::default(),
|
|
upstream_ended: row.upstream_ended,
|
|
blocked: row.blocked,
|
|
}
|
|
}
|
|
|
|
fn core_episode(row: &EpisodeRow) -> arr_core::Episode {
|
|
arr_core::Episode {
|
|
id: EpisodeId(row.id),
|
|
season_id: SeasonId(row.season_id),
|
|
season_number: u16::try_from(row.season_number).unwrap_or_default(),
|
|
number: u16::try_from(row.number).unwrap_or_default(),
|
|
title: row.title.clone(),
|
|
air_date: air_date(row.air_date.as_deref()),
|
|
wanted: row.wanted,
|
|
state: media_state(&row.state),
|
|
search_attempts: u32::try_from(row.search_attempts).unwrap_or_default(),
|
|
last_searched_at: None,
|
|
}
|
|
}
|
|
|
|
fn status_name(status: SeriesStatus) -> &'static str {
|
|
match status {
|
|
SeriesStatus::Airing => "airing",
|
|
SeriesStatus::Incomplete => "incomplete",
|
|
SeriesStatus::Waiting => "waiting",
|
|
SeriesStatus::Complete => "complete",
|
|
SeriesStatus::Ended => "ended",
|
|
}
|
|
}
|
|
|
|
fn with_status(row: &SeriesRow, episodes: &[arr_core::Episode], now: SystemTime) -> Series {
|
|
// §4.2: season 0 is invisible to status, so it stays out of the counters
|
|
// too. A series reading `complete` next to `42/52 eps` is the confusion
|
|
// this avoids. The season number rides on each episode (#131), so no
|
|
// parallel slice can be forgotten.
|
|
let wanted = episodes
|
|
.iter()
|
|
.filter(|episode| episode.wanted && episode.season_number != 0);
|
|
let available = wanted
|
|
.clone()
|
|
.filter(|episode| episode.state == MediaState::Available);
|
|
Series {
|
|
id: row.id,
|
|
tmdb_id: row.tmdb_id,
|
|
tvdb_id: row.tvdb_id,
|
|
title: row.title.clone(),
|
|
year: row.year,
|
|
original_language: row.original_language.clone(),
|
|
root_id: row.root_id,
|
|
auto_track: row.auto_track,
|
|
overrides: row.overrides.clone(),
|
|
upstream_ended: row.upstream_ended,
|
|
blocked: row.blocked,
|
|
poster_path: row.poster_path.clone(),
|
|
vote_average: row.vote_average,
|
|
status: status_name(derive_series_status(&core_series(row), episodes, now)).to_owned(),
|
|
wanted_episodes: i64::try_from(wanted.count()).unwrap_or(i64::MAX),
|
|
available_episodes: i64::try_from(available.count()).unwrap_or(i64::MAX),
|
|
}
|
|
}
|
|
|
|
/// Every episode in the library, keyed by the series it belongs to.
|
|
///
|
|
/// One query rather than one per series: the whole table is a few thousand
|
|
/// rows for a single household (§10), and the status of every listed series
|
|
/// needs all of them anyway.
|
|
async fn tv_by_series(state: &AppState) -> Result<HashMap<i64, Vec<arr_core::Episode>>, ApiError> {
|
|
let rows = sqlx::query_as!(
|
|
EpisodeRow,
|
|
r#"SELECT se.series_id AS "series_id!: i64", e.id AS "id!: i64", e.season_id AS "season_id!: i64", se.number AS "season_number!: i64", e.number AS "number!: i64", e.title AS "title!: String", e.air_date, e.wanted AS "wanted!: bool", e.state AS "state!: String", e.vanished AS "vanished!: bool", e.search_attempts AS "search_attempts!: i64", e.last_searched_at
|
|
FROM episodes e JOIN seasons se ON se.id = e.season_id"#
|
|
)
|
|
.fetch_all(pool(state)?)
|
|
.await?;
|
|
|
|
let mut episodes: HashMap<i64, Vec<arr_core::Episode>> = HashMap::new();
|
|
for row in &rows {
|
|
episodes
|
|
.entry(row.series_id)
|
|
.or_default()
|
|
.push(core_episode(row));
|
|
}
|
|
Ok(episodes)
|
|
}
|
|
|
|
async fn load_series_row(state: &AppState, id: i64) -> Result<SeriesRow, ApiError> {
|
|
sqlx::query_as!(SeriesRow, r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", tvdb_id, title AS "title!: String", year, original_language, root_id AS "root_id!: i64", auto_track AS "auto_track!: bool", overrides AS "overrides!: serde_json::Value", upstream_ended AS "upstream_ended!: bool", blocked AS "blocked!: bool", poster_path, vote_average, metadata_refreshed_at FROM series WHERE id = ?"#, id)
|
|
.fetch_optional(pool(state)?)
|
|
.await?
|
|
.ok_or(ApiError::SeriesNotFound)
|
|
}
|
|
|
|
async fn load_series(state: &AppState, id: i64) -> Result<Series, ApiError> {
|
|
let row = load_series_row(state, id).await?;
|
|
let episodes = sqlx::query_as!(
|
|
EpisodeRow,
|
|
r#"SELECT se.series_id AS "series_id!: i64", e.id AS "id!: i64", e.season_id AS "season_id!: i64", se.number AS "season_number!: i64", e.number AS "number!: i64", e.title AS "title!: String", e.air_date, e.wanted AS "wanted!: bool", e.state AS "state!: String", e.vanished AS "vanished!: bool", e.search_attempts AS "search_attempts!: i64", e.last_searched_at
|
|
FROM episodes e JOIN seasons se ON se.id = e.season_id WHERE se.series_id = ?"#,
|
|
id
|
|
)
|
|
.fetch_all(pool(state)?)
|
|
.await?;
|
|
let episodes: Vec<_> = episodes.iter().map(core_episode).collect();
|
|
Ok(with_status(&row, &episodes, SystemTime::now()))
|
|
}
|
|
|
|
async fn require_tv_root(state: &AppState, root_id: i64) -> Result<(), ApiError> {
|
|
let tv_root = sqlx::query_scalar!(
|
|
"SELECT EXISTS(SELECT 1 FROM roots WHERE id = ? AND kind = 'tv') AS 'exists!: bool'",
|
|
root_id
|
|
)
|
|
.fetch_one(pool(state)?)
|
|
.await?;
|
|
if tv_root {
|
|
Ok(())
|
|
} else {
|
|
Err(ApiError::Invalid("root_id must name a TV root".into()))
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Deserialize, IntoParams)]
|
|
pub struct ListSeriesQuery {
|
|
/// Restrict to series tagged with this owner (DESIGN.md §4.3).
|
|
pub owner_id: Option<i64>,
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/series", tag = "series",
|
|
params(ListSeriesQuery),
|
|
responses(
|
|
(status = 200, body = [Series]),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn list(
|
|
State(state): State<AppState>,
|
|
Query(query): Query<ListSeriesQuery>,
|
|
) -> Result<Json<Vec<Series>>, ApiError> {
|
|
let rows = if let Some(owner_id) = query.owner_id {
|
|
sqlx::query_as!(SeriesRow, r#"SELECT s.id AS "id!: i64", s.tmdb_id AS "tmdb_id!: i64", s.tvdb_id, s.title AS "title!: String", s.year, s.original_language, s.root_id AS "root_id!: i64", s.auto_track AS "auto_track!: bool", s.overrides AS "overrides!: serde_json::Value", s.upstream_ended AS "upstream_ended!: bool", s.blocked AS "blocked!: bool", poster_path, vote_average, s.metadata_refreshed_at FROM series s JOIN title_owners t ON t.title_kind = 'series' AND t.title_id = s.id WHERE t.owner_id = ? ORDER BY s.title, s.year, s.id"#, owner_id)
|
|
.fetch_all(pool(&state)?)
|
|
.await?
|
|
} else {
|
|
sqlx::query_as!(SeriesRow, r#"SELECT id AS "id!: i64", tmdb_id AS "tmdb_id!: i64", tvdb_id, title AS "title!: String", year, original_language, root_id AS "root_id!: i64", auto_track AS "auto_track!: bool", overrides AS "overrides!: serde_json::Value", upstream_ended AS "upstream_ended!: bool", blocked AS "blocked!: bool", poster_path, vote_average, metadata_refreshed_at FROM series ORDER BY title, year, id"#)
|
|
.fetch_all(pool(&state)?)
|
|
.await?
|
|
};
|
|
|
|
let episodes = tv_by_series(&state).await?;
|
|
let now = SystemTime::now();
|
|
let no_episodes: Vec<arr_core::Episode> = Vec::new();
|
|
Ok(Json(
|
|
rows.iter()
|
|
.map(|row| with_status(row, episodes.get(&row.id).unwrap_or(&no_episodes), now))
|
|
.collect(),
|
|
))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/series", tag = "series", request_body = CreateSeries,
|
|
responses(
|
|
(status = 201, body = Series),
|
|
(status = 409, body = ErrorBody),
|
|
(status = 422, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn create(
|
|
State(state): State<AppState>,
|
|
Json(input): Json<CreateSeries>,
|
|
) -> Result<(StatusCode, Json<Series>), ApiError> {
|
|
if input.title.trim().is_empty() || input.tmdb_id <= 0 {
|
|
return Err(ApiError::Invalid("tmdb_id and title are required".into()));
|
|
}
|
|
validate_overrides(&input.overrides)?;
|
|
require_tv_root(&state, input.root_id).await?;
|
|
let overrides = serde_json::to_string(&input.overrides)
|
|
.map_err(|error| ApiError::Invalid(error.to_string()))?;
|
|
let title = input.title.trim();
|
|
// §6.1: the TVDB id is what `t=tvsearch` is addressed by, but TMDB not
|
|
// knowing one must not block adding the series — the search falls back
|
|
// to the title text query until a refresh fills it in (#121). The same
|
|
// response carries §9.6's stored artwork fields, so a series added today
|
|
// has a poster before tomorrow's refresh. Best effort either way.
|
|
let tmdb_series = lookup_tmdb_series(&state, input.tmdb_id).await;
|
|
let tvdb_id = tmdb_series.as_ref().and_then(|s| s.tvdb_id).map(i64::from);
|
|
let poster_path = tmdb_series.as_ref().and_then(|s| s.poster_path.clone());
|
|
let backdrop_path = tmdb_series.as_ref().and_then(|s| s.backdrop_path.clone());
|
|
let vote_average = tmdb_series.as_ref().and_then(|s| s.vote_average);
|
|
let result = sqlx::query!(
|
|
"INSERT INTO series (tmdb_id, tvdb_id, title, year, original_language, root_id, auto_track, upstream_ended, blocked, overrides, poster_path, backdrop_path, vote_average) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
|
|
input.tmdb_id, tvdb_id, title, input.year, input.original_language, input.root_id,
|
|
input.auto_track, input.upstream_ended, input.blocked, overrides,
|
|
poster_path, backdrop_path, vote_average,
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
Ok((
|
|
StatusCode::CREATED,
|
|
Json(load_series(&state, result.last_insert_rowid()).await?),
|
|
))
|
|
}
|
|
|
|
/// Best effort: `None` when TMDB has no such id or cannot be reached.
|
|
async fn lookup_tmdb_series(state: &AppState, tmdb_id: i64) -> Option<arr_meta::Series> {
|
|
let client = tmdb_client(state).ok()?;
|
|
client.series(u32::try_from(tmdb_id).ok()?).await.ok()
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/series/{series_id}", tag = "series",
|
|
params(("series_id" = i64, Path, description = "Series row id")),
|
|
responses(
|
|
(status = 200, body = Series),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn get(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<Json<Series>, ApiError> {
|
|
Ok(Json(load_series(&state, id).await?))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
patch, path = "/api/series/{series_id}", tag = "series", request_body = UpdateSeries,
|
|
params(("series_id" = i64, Path, description = "Series row id")),
|
|
responses(
|
|
(status = 200, body = Series),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 409, body = ErrorBody),
|
|
(status = 422, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn update(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
Json(input): Json<UpdateSeries>,
|
|
) -> Result<Json<Series>, ApiError> {
|
|
let current = load_series_row(&state, id).await?;
|
|
let title = input.title.unwrap_or(current.title);
|
|
if title.trim().is_empty() {
|
|
return Err(ApiError::Invalid("title cannot be empty".into()));
|
|
}
|
|
let overrides = input.overrides.unwrap_or(current.overrides);
|
|
validate_overrides(&overrides)?;
|
|
let overrides =
|
|
serde_json::to_string(&overrides).map_err(|error| ApiError::Invalid(error.to_string()))?;
|
|
let title = title.trim();
|
|
let year = input.year.unwrap_or(current.year);
|
|
let original_language = input.original_language.unwrap_or(current.original_language);
|
|
let root_id = input.root_id.unwrap_or(current.root_id);
|
|
if input.root_id.is_some() {
|
|
require_tv_root(&state, root_id).await?;
|
|
}
|
|
let auto_track = input.auto_track.unwrap_or(current.auto_track);
|
|
let upstream_ended = input.upstream_ended.unwrap_or(current.upstream_ended);
|
|
let blocked = input.blocked.unwrap_or(current.blocked);
|
|
sqlx::query!("UPDATE series SET title = ?, year = ?, original_language = ?, root_id = ?, auto_track = ?, upstream_ended = ?, blocked = ?, overrides = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?", title, year, original_language, root_id, auto_track, upstream_ended, blocked, overrides, id)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
Ok(Json(load_series(&state, id).await?))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
delete, path = "/api/series/{series_id}", tag = "series",
|
|
params(("series_id" = i64, Path, description = "Series row id")),
|
|
responses(
|
|
(status = 204),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 409, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn delete(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<StatusCode, ApiError> {
|
|
// The row is loaded first so a missing series is 404 before anything
|
|
// touches the disk.
|
|
load_series_row(&state, id).await?;
|
|
remove_library_files(&state, id).await?;
|
|
// `media_files.path` is UNIQUE and the owner is polymorphic, so nothing
|
|
// cascades from the seasons and episodes rows (which the series row's
|
|
// delete does): leaving the rows behind would block re-importing the
|
|
// same paths after a re-add. Owner tags go with the title they tagged.
|
|
sqlx::query!(
|
|
"DELETE FROM media_files WHERE owner_kind = 'episode' AND owner_id IN (
|
|
SELECT e.id FROM episodes e JOIN seasons se ON se.id = e.season_id
|
|
WHERE se.series_id = ?)",
|
|
id
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
sqlx::query!(
|
|
"DELETE FROM title_owners WHERE title_kind = 'series' AND title_id = ?",
|
|
id
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
let result = sqlx::query!("DELETE FROM series WHERE id = ?", id)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
if result.rows_affected() == 0 {
|
|
return Err(ApiError::SeriesNotFound);
|
|
}
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
/// Unlink everything this series put under its root. Mirrors the movie
|
|
/// handler in `movies.rs`.
|
|
///
|
|
/// The service knows only what it wrote (§2), so the targets come from
|
|
/// `media_files`, never from a scan and never from re-deriving the §7.4 name
|
|
/// — a series renamed after import would derive a folder that does not exist
|
|
/// while the real one stayed. Each episode file resolves to its title folder,
|
|
/// which makes the delete atomic (§7.4): season subfolders, sidecar subtitles
|
|
/// and artwork go with it.
|
|
///
|
|
/// The torrent is untouched (§7.3). It keeps seeding under its own rule and
|
|
/// the reaper deletes it; a hardlinked file loses only its library name.
|
|
///
|
|
/// Failure leaves the database alone, so the operator sees the series still
|
|
/// there and can retry rather than losing the record of what is on disk.
|
|
async fn remove_library_files(state: &AppState, id: i64) -> Result<(), ApiError> {
|
|
let root = sqlx::query_scalar!(
|
|
r#"SELECT r.path AS "path!: String" FROM roots r JOIN series s ON s.root_id = r.id WHERE s.id = ?"#,
|
|
id
|
|
)
|
|
.fetch_one(pool(state)?)
|
|
.await?;
|
|
let paths = sqlx::query_scalar!(
|
|
r#"SELECT mf.path AS "path!: String"
|
|
FROM media_files mf
|
|
JOIN episodes e ON mf.owner_kind = 'episode' AND e.id = mf.owner_id
|
|
JOIN seasons se ON se.id = e.season_id
|
|
WHERE se.series_id = ?"#,
|
|
id
|
|
)
|
|
.fetch_all(pool(state)?)
|
|
.await?;
|
|
|
|
let mut targets: Vec<std::path::PathBuf> = Vec::new();
|
|
for path in &paths {
|
|
let Some(target) = crate::movies::title_target(&root, path) else {
|
|
// Outside its own root: not ours to delete. The row still goes,
|
|
// so the operator sees the series leave and the file stay.
|
|
tracing::warn!(%path, %root, "media file is outside its root, not deleted");
|
|
continue;
|
|
};
|
|
if !targets.contains(&target) {
|
|
targets.push(target);
|
|
}
|
|
}
|
|
|
|
for target in targets {
|
|
let metadata = match tokio::fs::symlink_metadata(&target).await {
|
|
Ok(metadata) => metadata,
|
|
// Already gone is the state we wanted.
|
|
Err(error) if error.kind() == std::io::ErrorKind::NotFound => continue,
|
|
Err(error) => return Err(ApiError::Filesystem(error.to_string())),
|
|
};
|
|
let removed = if metadata.is_dir() {
|
|
tokio::fs::remove_dir_all(&target).await
|
|
} else {
|
|
tokio::fs::remove_file(&target).await
|
|
};
|
|
match removed {
|
|
Ok(()) => tracing::info!(target = %target.display(), "removed library files"),
|
|
Err(error) if error.kind() == std::io::ErrorKind::NotFound => {}
|
|
Err(error) => return Err(ApiError::Filesystem(error.to_string())),
|
|
}
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
async fn load_seasons(state: &AppState, series_id: i64) -> Result<Vec<Season>, ApiError> {
|
|
let seasons = sqlx::query!(
|
|
// §9.6: newest-first, so season 0 lands last under plain numeric
|
|
// descending order — exactly where the design puts it.
|
|
r#"SELECT id AS "id!: i64", series_id AS "series_id!: i64", number AS "number!: i64", tracked AS "tracked!: bool", vanished AS "vanished!: bool" FROM seasons WHERE series_id = ? ORDER BY number DESC"#,
|
|
series_id
|
|
)
|
|
.fetch_all(pool(state)?)
|
|
.await?;
|
|
let episodes = sqlx::query_as!(
|
|
EpisodeRow,
|
|
r#"SELECT se.series_id AS "series_id!: i64", e.id AS "id!: i64", e.season_id AS "season_id!: i64", se.number AS "season_number!: i64", e.number AS "number!: i64", e.title AS "title!: String", e.air_date, e.wanted AS "wanted!: bool", e.state AS "state!: String", e.vanished AS "vanished!: bool", e.search_attempts AS "search_attempts!: i64", e.last_searched_at
|
|
FROM episodes e JOIN seasons se ON se.id = e.season_id WHERE se.series_id = ? ORDER BY se.number DESC, e.number DESC"#,
|
|
series_id
|
|
)
|
|
.fetch_all(pool(state)?)
|
|
.await?;
|
|
|
|
Ok(seasons
|
|
.into_iter()
|
|
.map(|season| Season {
|
|
id: season.id,
|
|
series_id: season.series_id,
|
|
number: season.number,
|
|
tracked: season.tracked,
|
|
vanished: season.vanished,
|
|
episodes: episodes
|
|
.iter()
|
|
.filter(|episode| episode.season_id == season.id)
|
|
.map(|episode| Episode {
|
|
id: episode.id,
|
|
series_id,
|
|
season_id: episode.season_id,
|
|
season_number: episode.season_number,
|
|
number: episode.number,
|
|
title: episode.title.clone(),
|
|
air_date: episode.air_date.clone(),
|
|
wanted: episode.wanted,
|
|
state: episode.state.clone(),
|
|
vanished: episode.vanished,
|
|
search_attempts: episode.search_attempts,
|
|
last_searched_at: episode.last_searched_at.clone(),
|
|
})
|
|
.collect(),
|
|
})
|
|
.collect())
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/series/{series_id}/seasons", tag = "series",
|
|
params(("series_id" = i64, Path, description = "Series row id")),
|
|
responses(
|
|
(status = 200, body = [Season]),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn seasons(
|
|
State(state): State<AppState>,
|
|
Path(series_id): Path<i64>,
|
|
) -> Result<Json<Vec<Season>>, ApiError> {
|
|
load_series_row(&state, series_id).await?;
|
|
Ok(Json(load_seasons(&state, series_id).await?))
|
|
}
|
|
|
|
/// Records a season metadata has revealed, applying the series' tracking rule.
|
|
#[utoipa::path(
|
|
post, path = "/api/series/{series_id}/seasons", tag = "series",
|
|
request_body = CreateSeason,
|
|
params(("series_id" = i64, Path, description = "Series row id")),
|
|
responses(
|
|
(status = 201, body = Season),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 409, body = ErrorBody),
|
|
(status = 422, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn create_season(
|
|
State(state): State<AppState>,
|
|
Path(series_id): Path<i64>,
|
|
Json(input): Json<CreateSeason>,
|
|
) -> Result<(StatusCode, Json<Season>), ApiError> {
|
|
let series = load_series_row(&state, series_id).await?;
|
|
if input.number < 0 {
|
|
return Err(ApiError::Invalid("season number cannot be negative".into()));
|
|
}
|
|
if input.episodes.iter().any(|episode| episode.number < 0) {
|
|
return Err(ApiError::Invalid(
|
|
"episode number cannot be negative".into(),
|
|
));
|
|
}
|
|
// The column rejects the empty string (#153); say so before the database
|
|
// has to.
|
|
if input
|
|
.episodes
|
|
.iter()
|
|
.any(|episode| episode.title.trim().is_empty())
|
|
{
|
|
return Err(ApiError::Invalid("episode title cannot be empty".into()));
|
|
}
|
|
let mut numbers: Vec<i64> = input
|
|
.episodes
|
|
.iter()
|
|
.map(|episode| episode.number)
|
|
.collect();
|
|
numbers.sort_unstable();
|
|
if numbers.windows(2).any(|pair| pair[0] == pair[1]) {
|
|
return Err(ApiError::Invalid(
|
|
"episode numbers must be unique within the season".into(),
|
|
));
|
|
}
|
|
|
|
// §4.1. The request does not say whether the episodes are wanted; the
|
|
// series' auto_track rule does, through the one function that owns it.
|
|
// #160: whether a refresh has happened yet rides in from the row — a
|
|
// hand-added season on a never-refreshed series is still seeding, and
|
|
// §4.1 does not track what was there at add time.
|
|
let mut revealed = [RefreshedSeason {
|
|
season: arr_core::Season {
|
|
id: SeasonId(0),
|
|
series_id: SeriesId(series_id),
|
|
number: u16::try_from(input.number).unwrap_or_default(),
|
|
tracked: false,
|
|
},
|
|
episodes: input
|
|
.episodes
|
|
.iter()
|
|
.map(|episode| arr_core::Episode {
|
|
id: EpisodeId(0),
|
|
season_id: SeasonId(0),
|
|
season_number: u16::try_from(input.number).unwrap_or_default(),
|
|
number: u16::try_from(episode.number).unwrap_or_default(),
|
|
title: episode.title.clone(),
|
|
air_date: air_date(episode.air_date.as_deref()),
|
|
wanted: false,
|
|
state: MediaState::Missing,
|
|
search_attempts: 0,
|
|
last_searched_at: None,
|
|
})
|
|
.collect(),
|
|
is_new: true,
|
|
}];
|
|
apply_auto_track(
|
|
&core_series(&series),
|
|
series.metadata_refreshed_at.is_some(),
|
|
&mut revealed,
|
|
);
|
|
let [revealed] = revealed;
|
|
|
|
// One transaction: a rejected episode must not leave the season behind,
|
|
// or the retry that fixes the request collides with it instead.
|
|
let mut transaction = pool(&state)?.begin().await?;
|
|
let season_id = sqlx::query!(
|
|
"INSERT INTO seasons (series_id, number, tracked) VALUES (?, ?, ?)",
|
|
series_id,
|
|
input.number,
|
|
revealed.season.tracked
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?
|
|
.last_insert_rowid();
|
|
|
|
for (episode, source) in revealed.episodes.iter().zip(&input.episodes) {
|
|
sqlx::query!(
|
|
"INSERT INTO episodes (season_id, number, title, air_date, wanted) VALUES (?, ?, ?, ?, ?)",
|
|
season_id,
|
|
source.number,
|
|
source.title,
|
|
source.air_date,
|
|
episode.wanted
|
|
)
|
|
.execute(&mut *transaction)
|
|
.await?;
|
|
}
|
|
transaction.commit().await?;
|
|
|
|
let seasons = load_seasons(&state, series_id).await?;
|
|
let season = seasons
|
|
.into_iter()
|
|
.find(|season| season.id == season_id)
|
|
.ok_or(ApiError::SeasonNotFound)?;
|
|
Ok((StatusCode::CREATED, Json(season)))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
patch, path = "/api/series/{series_id}/seasons/{season_number}", tag = "series",
|
|
request_body = UpdateSeason,
|
|
params(
|
|
("series_id" = i64, Path, description = "Series row id"),
|
|
("season_number" = i64, Path, description = "Season number, not its row id")
|
|
),
|
|
responses(
|
|
(status = 200, body = Season),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn update_season(
|
|
State(state): State<AppState>,
|
|
Path((series_id, number)): Path<(i64, i64)>,
|
|
Json(input): Json<UpdateSeason>,
|
|
) -> Result<Json<Season>, ApiError> {
|
|
load_series_row(&state, series_id).await?;
|
|
let season = sqlx::query!(
|
|
r#"SELECT id AS "id!: i64", tracked AS "tracked!: bool" FROM seasons WHERE series_id = ? AND number = ?"#,
|
|
series_id,
|
|
number
|
|
)
|
|
.fetch_optional(pool(&state)?)
|
|
.await?
|
|
.ok_or(ApiError::SeasonNotFound)?;
|
|
let season_id = season.id;
|
|
|
|
if let Some(tracked) = input.tracked {
|
|
sqlx::query!(
|
|
"UPDATE seasons SET tracked = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?",
|
|
tracked,
|
|
season_id
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
// §4.1, as `arr_core::tracking::apply_tracked` decides it: turning
|
|
// tracking on marks every already-revealed episode wanted; turning it
|
|
// off withdraws nothing. Only the off -> on transition writes intent.
|
|
if tracked && !season.tracked {
|
|
sqlx::query!(
|
|
"UPDATE episodes SET wanted = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE season_id = ?",
|
|
true,
|
|
season_id
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
}
|
|
}
|
|
// §4.1. Marking a season wanted is intent written onto its episodes, so
|
|
// an untracked series with one wanted season needs no special case.
|
|
if let Some(wanted) = input.wanted {
|
|
sqlx::query!(
|
|
"UPDATE episodes SET wanted = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE season_id = ?",
|
|
wanted,
|
|
season_id
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
}
|
|
|
|
let seasons = load_seasons(&state, series_id).await?;
|
|
seasons
|
|
.into_iter()
|
|
.find(|season| season.id == season_id)
|
|
.map(Json)
|
|
.ok_or(ApiError::SeasonNotFound)
|
|
}
|
|
|
|
async fn load_episode(state: &AppState, id: i64) -> Result<Episode, ApiError> {
|
|
let row = sqlx::query_as!(
|
|
EpisodeRow,
|
|
r#"SELECT se.series_id AS "series_id!: i64", e.id AS "id!: i64", e.season_id AS "season_id!: i64", se.number AS "season_number!: i64", e.number AS "number!: i64", e.title AS "title!: String", e.air_date, e.wanted AS "wanted!: bool", e.state AS "state!: String", e.vanished AS "vanished!: bool", e.search_attempts AS "search_attempts!: i64", e.last_searched_at
|
|
FROM episodes e JOIN seasons se ON se.id = e.season_id WHERE e.id = ?"#,
|
|
id
|
|
)
|
|
.fetch_optional(pool(state)?)
|
|
.await?
|
|
.ok_or(ApiError::EpisodeNotFound)?;
|
|
Ok(Episode {
|
|
id: row.id,
|
|
series_id: row.series_id,
|
|
season_id: row.season_id,
|
|
season_number: row.season_number,
|
|
number: row.number,
|
|
title: row.title,
|
|
air_date: row.air_date,
|
|
wanted: row.wanted,
|
|
state: row.state,
|
|
vanished: row.vanished,
|
|
search_attempts: row.search_attempts,
|
|
last_searched_at: row.last_searched_at,
|
|
})
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/episodes/{episode_id}", tag = "series",
|
|
params(("episode_id" = i64, Path, description = "Episode row id")),
|
|
responses(
|
|
(status = 200, body = Episode),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn get_episode(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<Json<Episode>, ApiError> {
|
|
Ok(Json(load_episode(&state, id).await?))
|
|
}
|
|
|
|
/// Sets the only intent the TV aggregate carries (§4.1).
|
|
#[utoipa::path(
|
|
patch, path = "/api/episodes/{episode_id}", tag = "series",
|
|
request_body = UpdateEpisode,
|
|
params(("episode_id" = i64, Path, description = "Episode row id")),
|
|
responses(
|
|
(status = 200, body = Episode),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn update_episode(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
Json(input): Json<UpdateEpisode>,
|
|
) -> Result<Json<Episode>, ApiError> {
|
|
load_episode(&state, id).await?;
|
|
if let Some(wanted) = input.wanted {
|
|
sqlx::query!(
|
|
"UPDATE episodes SET wanted = ?, updated_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now') WHERE id = ?",
|
|
wanted,
|
|
id
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
}
|
|
Ok(Json(load_episode(&state, id).await?))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/episodes/{episode_id}/search", tag = "series",
|
|
params(("episode_id" = i64, Path, description = "Episode row id")),
|
|
responses(
|
|
(status = 202, body = Accepted),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 409, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn search_episode(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<(StatusCode, Json<Accepted>), ApiError> {
|
|
load_episode(&state, id).await?;
|
|
// §6.3. `blocked` stops targeted search for the whole series.
|
|
let blocked = sqlx::query_scalar!(
|
|
r#"SELECT s.blocked AS "blocked!: bool" FROM episodes e JOIN seasons se ON se.id = e.season_id JOIN series s ON s.id = se.series_id WHERE e.id = ?"#,
|
|
id
|
|
)
|
|
.fetch_one(pool(&state)?)
|
|
.await?;
|
|
if blocked {
|
|
return Err(ApiError::Conflict("series is blocked".into()));
|
|
}
|
|
state
|
|
.send_episode_command(EpisodeCommand::Search { episode_id: id })
|
|
.map_err(|_| ApiError::Unavailable)?;
|
|
Ok((StatusCode::ACCEPTED, Json(Accepted { accepted: true })))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/episodes/{episode_id}/releases", tag = "series",
|
|
params(("episode_id" = i64, Path, description = "Episode row id")),
|
|
responses(
|
|
(status = 200, body = [Release]),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn episode_releases(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<Json<Vec<Release>>, ApiError> {
|
|
load_episode(&state, id).await?;
|
|
let mut releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN episode_releases er ON er.release_id = r.id WHERE er.episode_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, id)
|
|
.fetch_all(pool(&state)?)
|
|
.await?;
|
|
let policy = state
|
|
.database()
|
|
.ok_or(ApiError::Unavailable)?
|
|
.episode_policy(id)
|
|
.await
|
|
.map_err(|error| ApiError::Database(error.to_string()))?
|
|
.ok_or(ApiError::EpisodeNotFound)?
|
|
.policy;
|
|
rescore(&mut releases, &policy)?;
|
|
Ok(Json(releases))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/episodes/{episode_id}/releases/{release_id}/grab", tag = "series",
|
|
params(("episode_id" = i64, Path), ("release_id" = i64, Path)),
|
|
responses(
|
|
(status = 202, body = Accepted),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn grab_episode(
|
|
State(state): State<AppState>,
|
|
Path((episode_id, release_id)): Path<(i64, i64)>,
|
|
) -> Result<(StatusCode, Json<Accepted>), ApiError> {
|
|
let exists = sqlx::query_scalar!("SELECT EXISTS(SELECT 1 FROM episode_releases WHERE episode_id = ? AND release_id = ?) AS 'exists!: bool'", episode_id, release_id)
|
|
.fetch_one(pool(&state)?)
|
|
.await?;
|
|
if !exists {
|
|
return Err(ApiError::EpisodeNotFound);
|
|
}
|
|
state
|
|
.send_episode_command(EpisodeCommand::Grab {
|
|
episode_id,
|
|
release_id,
|
|
})
|
|
.map_err(|_| ApiError::Unavailable)?;
|
|
Ok((StatusCode::ACCEPTED, Json(Accepted { accepted: true })))
|
|
}
|
|
|
|
/// Resolves a season by its number within one series, so the deck is
|
|
/// addressed the way the UI shows seasons (`/series/{id}/seasons/{n}`).
|
|
async fn load_season_id(state: &AppState, series_id: i64, number: i64) -> Result<i64, ApiError> {
|
|
sqlx::query_scalar!(
|
|
r#"SELECT id AS "id!: i64" FROM seasons WHERE series_id = ? AND number = ?"#,
|
|
series_id,
|
|
number
|
|
)
|
|
.fetch_optional(pool(state)?)
|
|
.await?
|
|
.ok_or(ApiError::SeasonNotFound)
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/series/{series_id}/seasons/{season_number}/search", tag = "series",
|
|
params(
|
|
("series_id" = i64, Path, description = "Series row id"),
|
|
("season_number" = i64, Path, description = "Season number, not its row id")
|
|
),
|
|
responses(
|
|
(status = 202, body = Accepted),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 409, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn search_season(
|
|
State(state): State<AppState>,
|
|
Path((series_id, number)): Path<(i64, i64)>,
|
|
) -> Result<(StatusCode, Json<Accepted>), ApiError> {
|
|
load_series_row(&state, series_id).await?;
|
|
let season_id = load_season_id(&state, series_id, number).await?;
|
|
// §6.3. `blocked` stops targeted search for the whole series.
|
|
let blocked = sqlx::query_scalar!(
|
|
r#"SELECT blocked AS "blocked!: bool" FROM series WHERE id = ?"#,
|
|
series_id
|
|
)
|
|
.fetch_one(pool(&state)?)
|
|
.await?;
|
|
if blocked {
|
|
return Err(ApiError::Conflict("series is blocked".into()));
|
|
}
|
|
state
|
|
.send_season_command(SeasonCommand::Search { season_id })
|
|
.map_err(|_| ApiError::Unavailable)?;
|
|
Ok((StatusCode::ACCEPTED, Json(Accepted { accepted: true })))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/series/{series_id}/seasons/{season_number}/releases", tag = "series",
|
|
params(
|
|
("series_id" = i64, Path, description = "Series row id"),
|
|
("season_number" = i64, Path, description = "Season number, not its row id")
|
|
),
|
|
responses(
|
|
(status = 200, body = [Release]),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn season_releases(
|
|
State(state): State<AppState>,
|
|
Path((series_id, number)): Path<(i64, i64)>,
|
|
) -> Result<Json<Vec<Release>>, ApiError> {
|
|
load_series_row(&state, series_id).await?;
|
|
let season_id = load_season_id(&state, series_id, number).await?;
|
|
let mut releases = sqlx::query_as!(Release, r#"SELECT r.id AS "id!: i64", r.indexer_id AS "indexer_id!: i64", r.guid AS "guid!: String", r.name AS "name!: String", r.size AS "size!: i64", r.seeders, r.publish_date, r.download_url AS "download_url!: String", r.parsed AS "parsed!: serde_json::Value", r.score, r.verdict, r.rejected_rule FROM releases r JOIN season_releases sr ON sr.release_id = r.id WHERE sr.season_id = ? ORDER BY CASE r.verdict WHEN 'eligible' THEN 0 WHEN 'waived' THEN 1 ELSE 2 END, r.score DESC, r.id"#, season_id)
|
|
.fetch_all(pool(&state)?)
|
|
.await?;
|
|
let policy = state
|
|
.database()
|
|
.ok_or(ApiError::Unavailable)?
|
|
.season_policy(season_id)
|
|
.await
|
|
.map_err(|error| ApiError::Database(error.to_string()))?
|
|
.ok_or(ApiError::SeasonNotFound)?
|
|
.policy;
|
|
rescore(&mut releases, &policy)?;
|
|
Ok(Json(releases))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
post, path = "/api/series/{series_id}/seasons/{season_number}/releases/{release_id}/grab", tag = "series",
|
|
params(("series_id" = i64, Path), ("season_number" = i64, Path), ("release_id" = i64, Path)),
|
|
responses(
|
|
(status = 202, body = Accepted),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn grab_season_release(
|
|
State(state): State<AppState>,
|
|
Path((series_id, number, release_id)): Path<(i64, i64, i64)>,
|
|
) -> Result<(StatusCode, Json<Accepted>), ApiError> {
|
|
load_series_row(&state, series_id).await?;
|
|
let season_id = load_season_id(&state, series_id, number).await?;
|
|
let exists = sqlx::query_scalar!("SELECT EXISTS(SELECT 1 FROM season_releases WHERE season_id = ? AND release_id = ?) AS 'exists!: bool'", season_id, release_id)
|
|
.fetch_one(pool(&state)?)
|
|
.await?;
|
|
if !exists {
|
|
return Err(ApiError::SeasonNotFound);
|
|
}
|
|
state
|
|
.send_season_command(SeasonCommand::Grab {
|
|
season_id,
|
|
release_id,
|
|
})
|
|
.map_err(|_| ApiError::Unavailable)?;
|
|
Ok((StatusCode::ACCEPTED, Json(Accepted { accepted: true })))
|
|
}
|
|
|
|
/// One imported episode file, keyed to its episode so the detail view can
|
|
/// attach the file's probed §7.4 attributes to the episode row.
|
|
#[derive(Debug, Clone, Serialize, ToSchema)]
|
|
pub struct EpisodeFile {
|
|
pub episode_id: i64,
|
|
pub path: String,
|
|
pub size: i64,
|
|
pub probed: Option<serde_json::Value>,
|
|
/// The §5.7 rule relaxed to allow this import, when one was.
|
|
pub waiver: Option<String>,
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/series/{series_id}/files", tag = "series",
|
|
params(("series_id" = i64, Path, description = "Series row id")),
|
|
responses(
|
|
(status = 200, body = [EpisodeFile]),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn files(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<Json<Vec<EpisodeFile>>, ApiError> {
|
|
load_series_row(&state, id).await?;
|
|
let files = sqlx::query_as!(EpisodeFile, r#"SELECT e.id AS "episode_id!: i64", mf.path AS "path!: String", mf.size AS "size!: i64", mf.probed AS "probed?: serde_json::Value", json_extract(mf.waiver, '$.rule') AS "waiver?: String" FROM media_files mf JOIN episodes e ON mf.owner_kind = 'episode' AND e.id = mf.owner_id JOIN seasons se ON se.id = e.season_id WHERE se.series_id = ? ORDER BY mf.path"#, id)
|
|
.fetch_all(pool(&state)?)
|
|
.await?;
|
|
Ok(Json(files))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/series/{series_id}/owners", tag = "series",
|
|
params(("series_id" = i64, Path, description = "Series row id")),
|
|
responses(
|
|
(status = 200, body = [Owner]),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn list_owners(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<Json<Vec<Owner>>, ApiError> {
|
|
load_series_row(&state, id).await?;
|
|
let owners = sqlx::query_as!(
|
|
Owner,
|
|
r#"SELECT o.id AS "id!: i64", o.name AS "name!: String", o.ntfy_topic AS "ntfy_topic!: String"
|
|
FROM owners o
|
|
JOIN title_owners t ON t.owner_id = o.id
|
|
WHERE t.title_kind = 'series' AND t.title_id = ?
|
|
ORDER BY o.name"#,
|
|
id
|
|
)
|
|
.fetch_all(pool(&state)?)
|
|
.await?;
|
|
Ok(Json(owners))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
put, path = "/api/series/{series_id}/owners/{owner_id}", tag = "series",
|
|
params(("series_id" = i64, Path), ("owner_id" = i64, Path)),
|
|
responses(
|
|
(status = 204),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn tag_owner(
|
|
State(state): State<AppState>,
|
|
Path((series_id, owner_id)): Path<(i64, i64)>,
|
|
) -> Result<StatusCode, ApiError> {
|
|
load_series_row(&state, series_id).await?;
|
|
let owner_exists = sqlx::query_scalar!(
|
|
"SELECT EXISTS(SELECT 1 FROM owners WHERE id = ?) AS 'exists!: bool'",
|
|
owner_id
|
|
)
|
|
.fetch_one(pool(&state)?)
|
|
.await?;
|
|
if !owner_exists {
|
|
return Err(ApiError::OwnerNotFound);
|
|
}
|
|
sqlx::query!(
|
|
"INSERT INTO title_owners (title_kind, title_id, owner_id) VALUES ('series', ?, ?) ON CONFLICT DO NOTHING",
|
|
series_id, owner_id
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
#[utoipa::path(
|
|
delete, path = "/api/series/{series_id}/owners/{owner_id}", tag = "series",
|
|
params(("series_id" = i64, Path), ("owner_id" = i64, Path)),
|
|
responses(
|
|
(status = 204),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn untag_owner(
|
|
State(state): State<AppState>,
|
|
Path((series_id, owner_id)): Path<(i64, i64)>,
|
|
) -> Result<StatusCode, ApiError> {
|
|
load_series_row(&state, series_id).await?;
|
|
sqlx::query!(
|
|
"DELETE FROM title_owners WHERE title_kind = 'series' AND title_id = ? AND owner_id = ?",
|
|
series_id,
|
|
owner_id
|
|
)
|
|
.execute(pool(&state)?)
|
|
.await?;
|
|
Ok(StatusCode::NO_CONTENT)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::{router, Upstreams};
|
|
|
|
async fn application() -> (tempfile::TempDir, AppState, String) {
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
|
let database = arr_db::Db::connect(dir.path().join("arr.db"))
|
|
.await
|
|
.expect("connect database");
|
|
database.migrate().await.expect("migrate database");
|
|
let state = AppState::new(Upstreams::new(
|
|
"http://127.0.0.1:1".into(),
|
|
"http://127.0.0.1:1".into(),
|
|
))
|
|
.expect("state")
|
|
.with_database(database);
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
|
|
.await
|
|
.expect("bind");
|
|
let address = listener.local_addr().expect("address");
|
|
let app = router(state.clone());
|
|
tokio::spawn(async move { axum::serve(listener, app).await.expect("serve") });
|
|
(dir, state, format!("http://{address}"))
|
|
}
|
|
|
|
async fn tv_root(state: &AppState, audience: &str) -> i64 {
|
|
sqlx::query_scalar("SELECT id FROM roots WHERE kind = 'tv' AND audience = ?")
|
|
.bind(audience)
|
|
.fetch_one(state.database().expect("database").pool())
|
|
.await
|
|
.expect("TV root")
|
|
}
|
|
|
|
async fn add_series(base: &str, root_id: i64, auto_track: bool) -> serde_json::Value {
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series"))
|
|
.json(&serde_json::json!({
|
|
"tmdb_id": 82_728, "title": "Bluey", "year": 2018,
|
|
"original_language": "en", "root_id": root_id,
|
|
"auto_track": auto_track
|
|
}))
|
|
.send()
|
|
.await
|
|
.expect("create series");
|
|
assert_eq!(response.status(), StatusCode::CREATED);
|
|
response.json().await.expect("series json")
|
|
}
|
|
|
|
async fn add_season(
|
|
base: &str,
|
|
series_id: i64,
|
|
number: i64,
|
|
episodes: serde_json::Value,
|
|
) -> serde_json::Value {
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series/{series_id}/seasons"))
|
|
.json(&serde_json::json!({ "number": number, "episodes": episodes }))
|
|
.send()
|
|
.await
|
|
.expect("create season");
|
|
assert_eq!(response.status(), StatusCode::CREATED);
|
|
response.json().await.expect("season json")
|
|
}
|
|
|
|
/// §9.6: the three stored artwork fields come off the series detail
|
|
/// response at add time — the same call that used to fetch only the
|
|
/// TVDB id — so a series added today has a poster before tomorrow's
|
|
/// refresh.
|
|
#[tokio::test]
|
|
async fn creating_a_series_stores_artwork_from_tmdb() {
|
|
let tmdb = wiremock::MockServer::start().await;
|
|
wiremock::Mock::given(wiremock::matchers::method("GET"))
|
|
.and(wiremock::matchers::path("/tv/82728"))
|
|
.respond_with(
|
|
wiremock::ResponseTemplate::new(200).set_body_json(serde_json::json!({
|
|
"id": 82_728,
|
|
"name": "Bluey",
|
|
"status": "Returning Series",
|
|
"poster_path": "/bluey.jpg",
|
|
"backdrop_path": "/bluey-wide.jpg",
|
|
"vote_average": 8.417,
|
|
"external_ids": {"tvdb_id": 361_391}
|
|
})),
|
|
)
|
|
.mount(&tmdb)
|
|
.await;
|
|
|
|
let dir = tempfile::tempdir().expect("tempdir");
|
|
let database = arr_db::Db::connect(dir.path().join("arr.db"))
|
|
.await
|
|
.expect("connect database");
|
|
database.migrate().await.expect("migrate database");
|
|
let state = AppState::new(
|
|
Upstreams::new("http://127.0.0.1:1".into(), "http://127.0.0.1:1".into())
|
|
.with_tmdb_url(tmdb.uri())
|
|
.with_tmdb_api_key(Some("key".into())),
|
|
)
|
|
.expect("state")
|
|
.with_database(database);
|
|
let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
|
|
.await
|
|
.expect("bind");
|
|
let address = listener.local_addr().expect("address");
|
|
let served = state.clone();
|
|
tokio::spawn(async move { axum::serve(listener, router(served)).await.expect("serve") });
|
|
let base = format!("http://{address}");
|
|
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series"))
|
|
.json(&serde_json::json!({
|
|
"tmdb_id": 82_728, "title": "Bluey",
|
|
"original_language": "en", "root_id": 3
|
|
}))
|
|
.send()
|
|
.await
|
|
.expect("create series");
|
|
assert_eq!(response.status(), StatusCode::CREATED);
|
|
let series_id = response.json::<serde_json::Value>().await.expect("json")["id"]
|
|
.as_i64()
|
|
.expect("series id");
|
|
|
|
let (tvdb_id, poster, backdrop, vote): (
|
|
Option<i64>,
|
|
Option<String>,
|
|
Option<String>,
|
|
Option<f64>,
|
|
) = sqlx::query_as(
|
|
"SELECT tvdb_id, poster_path, backdrop_path, vote_average FROM series WHERE id = ?",
|
|
)
|
|
.bind(series_id)
|
|
.fetch_one(state.database().expect("database").pool())
|
|
.await
|
|
.expect("series row");
|
|
assert_eq!(tvdb_id, Some(361_391));
|
|
assert_eq!(poster.as_deref(), Some("/bluey.jpg"));
|
|
assert_eq!(backdrop.as_deref(), Some("/bluey-wide.jpg"));
|
|
assert_eq!(vote, Some(8.417));
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn series_must_sit_on_a_tv_root() {
|
|
let (_dir, state, base) = application().await;
|
|
let movie_root: i64 =
|
|
sqlx::query_scalar("SELECT id FROM roots WHERE kind = 'movie' LIMIT 1")
|
|
.fetch_one(state.database().expect("database").pool())
|
|
.await
|
|
.expect("movie root");
|
|
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series"))
|
|
.json(&serde_json::json!({
|
|
"tmdb_id": 82_728, "title": "Bluey", "root_id": movie_root
|
|
}))
|
|
.send()
|
|
.await
|
|
.expect("create series");
|
|
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
|
|
}
|
|
|
|
/// #160. A season added before the series' first metadata refresh is part
|
|
/// of the back catalogue at add time, so the rule does not track it. Once
|
|
/// a refresh has happened, a hand-revealed season is genuinely new and
|
|
/// arrives tracked with its episodes wanted.
|
|
#[tokio::test]
|
|
async fn auto_track_decides_whether_a_new_season_arrives_wanted() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "kids").await;
|
|
|
|
let tracked = add_series(&base, root_id, true).await;
|
|
let tracked_id = tracked["id"].as_i64().expect("id");
|
|
// Seeding: no refresh has ever stamped this series.
|
|
let season = add_season(
|
|
&base,
|
|
tracked_id,
|
|
1,
|
|
serde_json::json!([
|
|
{"number": 1, "title": "The Magic Xylophone", "air_date": "2018-10-01"},
|
|
{"number": 2, "title": "Hospital", "air_date": "2018-10-02"}
|
|
]),
|
|
)
|
|
.await;
|
|
assert_eq!(season["tracked"], false);
|
|
assert!(
|
|
season["episodes"]
|
|
.as_array()
|
|
.expect("episodes")
|
|
.iter()
|
|
.all(|episode| episode["wanted"] == false),
|
|
"§4.1: the back catalogue at add time is never auto-tracked"
|
|
);
|
|
|
|
sqlx::query(
|
|
"UPDATE series SET metadata_refreshed_at = strftime('%Y-%m-%dT%H:%M:%fZ', 'now')
|
|
WHERE id = ?",
|
|
)
|
|
.bind(tracked_id)
|
|
.execute(state.database().expect("database").pool())
|
|
.await
|
|
.expect("stamp refreshed");
|
|
let season = add_season(
|
|
&base,
|
|
tracked_id,
|
|
2,
|
|
serde_json::json!([
|
|
{"number": 1, "title": "Dance Mode", "air_date": "2019-04-01"}
|
|
]),
|
|
)
|
|
.await;
|
|
assert_eq!(season["tracked"], true);
|
|
assert!(
|
|
season["episodes"]
|
|
.as_array()
|
|
.expect("episodes")
|
|
.iter()
|
|
.all(|episode| episode["wanted"] == true),
|
|
"§4.1: from the second refresh onward the rule tracks what is new"
|
|
);
|
|
|
|
let untracked_id = sqlx::query_scalar::<_, i64>(
|
|
"INSERT INTO series (tmdb_id, title, root_id, auto_track) VALUES (1668, 'Friends', ?, 0) RETURNING id",
|
|
)
|
|
.bind(root_id)
|
|
.fetch_one(state.database().expect("database").pool())
|
|
.await
|
|
.expect("untracked series");
|
|
let season = add_season(
|
|
&base,
|
|
untracked_id,
|
|
2,
|
|
serde_json::json!([{"number": 1, "title": "The One", "air_date": "1995-09-21"}]),
|
|
)
|
|
.await;
|
|
assert_eq!(season["tracked"], false);
|
|
assert_eq!(season["episodes"][0]["wanted"], false);
|
|
}
|
|
|
|
/// #153. An empty episode title is rejected up front — the column and the
|
|
/// TMDB boundary both refuse it, so the API must too.
|
|
#[tokio::test]
|
|
async fn an_empty_episode_title_is_rejected() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
|
|
for title in ["", " "] {
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series/{series_id}/seasons"))
|
|
.json(&serde_json::json!({"number": 1, "episodes": [
|
|
{"number": 1, "title": title}
|
|
]}))
|
|
.send()
|
|
.await
|
|
.expect("create season");
|
|
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
|
|
}
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_rejected_season_leaves_nothing_behind_to_retry_over() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series/{series_id}/seasons"))
|
|
.json(&serde_json::json!({"number": 1, "episodes": [
|
|
{"number": 1, "title": "One"},
|
|
{"number": 1, "title": "One again"}
|
|
]}))
|
|
.send()
|
|
.await
|
|
.expect("create season");
|
|
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
|
|
|
|
let seasons: i64 = sqlx::query_scalar("SELECT count(*) FROM seasons")
|
|
.fetch_one(state.database().expect("database").pool())
|
|
.await
|
|
.expect("count seasons");
|
|
assert_eq!(seasons, 0, "the season number stays free for the retry");
|
|
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "One"}]),
|
|
)
|
|
.await;
|
|
assert_eq!(season["number"], 1);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_vanished_season_reaches_the_seasons_endpoint() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let clean = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "One"}]),
|
|
)
|
|
.await;
|
|
assert_eq!(clean["vanished"], false);
|
|
add_season(
|
|
&base,
|
|
series_id,
|
|
2,
|
|
serde_json::json!([{"number": 1, "title": "One"}]),
|
|
)
|
|
.await;
|
|
|
|
sqlx::query("UPDATE seasons SET vanished = 1 WHERE series_id = ? AND number = 2")
|
|
.bind(series_id)
|
|
.execute(state.database().expect("database").pool())
|
|
.await
|
|
.expect("flag season vanished");
|
|
|
|
let seasons: serde_json::Value = reqwest::Client::new()
|
|
.get(format!("{base}/api/series/{series_id}/seasons"))
|
|
.send()
|
|
.await
|
|
.expect("list seasons")
|
|
.json()
|
|
.await
|
|
.expect("seasons json");
|
|
let seasons = seasons.as_array().expect("seasons array");
|
|
let vanished = |number: i64| {
|
|
seasons
|
|
.iter()
|
|
.find(|season| season["number"] == number)
|
|
.expect("season")["vanished"]
|
|
.clone()
|
|
};
|
|
assert_eq!(vanished(1), false);
|
|
assert_eq!(
|
|
vanished(2),
|
|
true,
|
|
"#141: the conflict flag is not stopped at the database"
|
|
);
|
|
}
|
|
|
|
/// §9.6: seasons come back newest-first within a series and episodes
|
|
/// newest-first within each season, with season 0 wherever descending
|
|
/// numeric order puts it — last. The SPA renders this order as given,
|
|
/// so it is the API's to get right (#162).
|
|
#[tokio::test]
|
|
async fn seasons_and_episodes_are_returned_newest_first() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
for (season, episodes) in [
|
|
(
|
|
0,
|
|
serde_json::json!([
|
|
{"number": 1, "title": "Special one"},
|
|
{"number": 2, "title": "Special two"}
|
|
]),
|
|
),
|
|
(1, serde_json::json!([{"number": 1, "title": "Pilot"}])),
|
|
(
|
|
2,
|
|
serde_json::json!([
|
|
{"number": 1, "title": "One"},
|
|
{"number": 2, "title": "Two"},
|
|
{"number": 3, "title": "Three"}
|
|
]),
|
|
),
|
|
] {
|
|
add_season(&base, series_id, season, episodes).await;
|
|
}
|
|
|
|
let seasons: serde_json::Value =
|
|
reqwest::get(format!("{base}/api/series/{series_id}/seasons"))
|
|
.await
|
|
.expect("list seasons")
|
|
.json()
|
|
.await
|
|
.expect("seasons json");
|
|
let seasons = seasons.as_array().expect("seasons array");
|
|
let numbers: Vec<i64> = seasons
|
|
.iter()
|
|
.map(|season| season["number"].as_i64().expect("number"))
|
|
.collect();
|
|
assert_eq!(numbers, [2, 1, 0], "§9.6: newest-first within the series");
|
|
|
|
let episode_numbers = |index: usize| -> Vec<i64> {
|
|
seasons[index]["episodes"]
|
|
.as_array()
|
|
.expect("episodes")
|
|
.iter()
|
|
.map(|episode| episode["number"].as_i64().expect("episode number"))
|
|
.collect()
|
|
};
|
|
assert_eq!(
|
|
episode_numbers(0),
|
|
[3, 2, 1],
|
|
"§9.6: newest-first in a season"
|
|
);
|
|
assert_eq!(episode_numbers(1), [1]);
|
|
assert_eq!(episode_numbers(2), [2, 1]);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn intent_is_set_on_seasons_and_on_single_episodes() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
2,
|
|
serde_json::json!([
|
|
{"number": 1, "title": "One", "air_date": "2020-01-01"},
|
|
{"number": 2, "title": "Two", "air_date": "2020-01-08"}
|
|
]),
|
|
)
|
|
.await;
|
|
assert_eq!(season["episodes"][0]["wanted"], false);
|
|
|
|
// The whole season, in one click.
|
|
let updated: serde_json::Value = reqwest::Client::new()
|
|
.patch(format!("{base}/api/series/{series_id}/seasons/2"))
|
|
.json(&serde_json::json!({"wanted": true}))
|
|
.send()
|
|
.await
|
|
.expect("update season")
|
|
.json()
|
|
.await
|
|
.expect("season json");
|
|
assert!(updated["episodes"]
|
|
.as_array()
|
|
.expect("episodes")
|
|
.iter()
|
|
.all(|episode| episode["wanted"] == true));
|
|
assert_eq!(
|
|
updated["tracked"], false,
|
|
"§4.1: wanting a season is not tracking the series"
|
|
);
|
|
|
|
// And one episode on its own.
|
|
let episode_id = updated["episodes"][1]["id"].as_i64().expect("episode id");
|
|
let episode: serde_json::Value = reqwest::Client::new()
|
|
.patch(format!("{base}/api/episodes/{episode_id}"))
|
|
.json(&serde_json::json!({"wanted": false}))
|
|
.send()
|
|
.await
|
|
.expect("update episode")
|
|
.json()
|
|
.await
|
|
.expect("episode json");
|
|
assert_eq!(episode["wanted"], false);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn tracking_a_season_marks_revealed_episodes_and_off_withdraws_nothing() {
|
|
async fn patch_season(
|
|
base: &str,
|
|
series_id: i64,
|
|
body: serde_json::Value,
|
|
) -> serde_json::Value {
|
|
reqwest::Client::new()
|
|
.patch(format!("{base}/api/series/{series_id}/seasons/1"))
|
|
.json(&body)
|
|
.send()
|
|
.await
|
|
.expect("update season")
|
|
.json()
|
|
.await
|
|
.expect("season json")
|
|
}
|
|
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([
|
|
{"number": 1, "title": "One", "air_date": "2020-01-01"},
|
|
{"number": 2, "title": "Two", "air_date": "2020-01-08"}
|
|
]),
|
|
)
|
|
.await;
|
|
assert_eq!(season["tracked"], false);
|
|
assert_eq!(season["episodes"][0]["wanted"], false);
|
|
|
|
let updated = patch_season(&base, series_id, serde_json::json!({"tracked": true})).await;
|
|
assert_eq!(updated["tracked"], true);
|
|
assert!(
|
|
updated["episodes"]
|
|
.as_array()
|
|
.expect("episodes")
|
|
.iter()
|
|
.all(|episode| episode["wanted"] == true),
|
|
"§4.1: turning tracked on marks every revealed episode wanted"
|
|
);
|
|
|
|
// Turning it off withdraws nothing.
|
|
let updated = patch_season(&base, series_id, serde_json::json!({"tracked": false})).await;
|
|
assert_eq!(updated["tracked"], false);
|
|
assert!(
|
|
updated["episodes"]
|
|
.as_array()
|
|
.expect("episodes")
|
|
.iter()
|
|
.all(|episode| episode["wanted"] == true),
|
|
"§4.1: leaf intent is never removed implicitly"
|
|
);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn listed_series_carry_a_derived_status() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
assert_eq!(
|
|
series["status"], "complete",
|
|
"nothing wanted is nothing missing"
|
|
);
|
|
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "Pilot", "air_date": "2001-01-01"}]),
|
|
)
|
|
.await;
|
|
let episode_id = season["episodes"][0]["id"].as_i64().expect("episode id");
|
|
reqwest::Client::new()
|
|
.patch(format!("{base}/api/episodes/{episode_id}"))
|
|
.json(&serde_json::json!({"wanted": true}))
|
|
.send()
|
|
.await
|
|
.expect("want the episode");
|
|
|
|
let listed: Vec<serde_json::Value> = reqwest::get(format!("{base}/api/series"))
|
|
.await
|
|
.expect("list")
|
|
.json()
|
|
.await
|
|
.expect("list json");
|
|
assert_eq!(listed.len(), 1);
|
|
assert_eq!(
|
|
listed[0]["status"], "incomplete",
|
|
"§4.2: an aired wanted episode with no file"
|
|
);
|
|
assert_eq!(listed[0]["wanted_episodes"], 1);
|
|
assert_eq!(listed[0]["available_episodes"], 0);
|
|
|
|
sqlx::query("UPDATE episodes SET state = 'available' WHERE id = ?")
|
|
.bind(episode_id)
|
|
.execute(state.database().expect("database").pool())
|
|
.await
|
|
.expect("import the episode");
|
|
let after: serde_json::Value = reqwest::get(format!("{base}/api/series/{series_id}"))
|
|
.await
|
|
.expect("get")
|
|
.json()
|
|
.await
|
|
.expect("series json");
|
|
assert_eq!(after["status"], "complete");
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn manual_episode_actions_are_scoped_and_respect_blocked() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "Pilot", "air_date": "2001-01-01"}]),
|
|
)
|
|
.await;
|
|
let episode_id = season["episodes"][0]["id"].as_i64().expect("episode id");
|
|
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/episodes/{episode_id}/search"))
|
|
.send()
|
|
.await
|
|
.expect("search");
|
|
assert_eq!(response.status(), StatusCode::ACCEPTED);
|
|
assert_eq!(
|
|
state.next_episode_command().await.expect("command"),
|
|
EpisodeCommand::Search { episode_id }
|
|
);
|
|
|
|
let pool = state.database().expect("database").pool();
|
|
let release_id = sqlx::query_scalar::<_, i64>("INSERT INTO releases (indexer_id, guid, name, size, download_url, parsed, score, verdict) VALUES (7, 'guid', 'Bluey S01E01 1080p WEB-DL', 1000, 'url', '{}', 42, 'eligible') RETURNING id")
|
|
.fetch_one(pool)
|
|
.await
|
|
.expect("release");
|
|
sqlx::query("INSERT INTO episode_releases (episode_id, release_id) VALUES (?, ?)")
|
|
.bind(episode_id)
|
|
.bind(release_id)
|
|
.execute(pool)
|
|
.await
|
|
.expect("association");
|
|
|
|
let releases: Vec<serde_json::Value> =
|
|
reqwest::get(format!("{base}/api/episodes/{episode_id}/releases"))
|
|
.await
|
|
.expect("releases")
|
|
.json()
|
|
.await
|
|
.expect("releases json");
|
|
assert_eq!(releases[0]["verdict"], "eligible");
|
|
|
|
let response = reqwest::Client::new()
|
|
.post(format!(
|
|
"{base}/api/episodes/{episode_id}/releases/{release_id}/grab"
|
|
))
|
|
.send()
|
|
.await
|
|
.expect("grab");
|
|
assert_eq!(response.status(), StatusCode::ACCEPTED);
|
|
assert_eq!(
|
|
state.next_episode_command().await.expect("command"),
|
|
EpisodeCommand::Grab {
|
|
episode_id,
|
|
release_id
|
|
}
|
|
);
|
|
|
|
// A release belonging to another episode is not grabbable through
|
|
// this one.
|
|
let other = sqlx::query_scalar::<_, i64>("INSERT INTO releases (indexer_id, guid, name, size, download_url, parsed, verdict) VALUES (7, 'other', 'other', 1, 'url', '{}', 'eligible') RETURNING id")
|
|
.fetch_one(pool)
|
|
.await
|
|
.expect("other release");
|
|
let response = reqwest::Client::new()
|
|
.post(format!(
|
|
"{base}/api/episodes/{episode_id}/releases/{other}/grab"
|
|
))
|
|
.send()
|
|
.await
|
|
.expect("grab");
|
|
assert_eq!(response.status(), StatusCode::NOT_FOUND);
|
|
|
|
reqwest::Client::new()
|
|
.patch(format!("{base}/api/series/{series_id}"))
|
|
.json(&serde_json::json!({"blocked": true}))
|
|
.send()
|
|
.await
|
|
.expect("block the series");
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/episodes/{episode_id}/search"))
|
|
.send()
|
|
.await
|
|
.expect("blocked search");
|
|
assert_eq!(response.status(), StatusCode::CONFLICT);
|
|
}
|
|
|
|
/// Issue #125: seasons get the same §9.3 surface as movies and episodes —
|
|
/// a targeted search, a deck scoped to one season and rescored against
|
|
/// the current policy, and a grab by release id.
|
|
#[tokio::test]
|
|
async fn manual_season_actions_are_scoped_and_rescore_the_deck() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "Pilot", "air_date": "2001-01-01"}]),
|
|
)
|
|
.await;
|
|
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series/{series_id}/seasons/1/search"))
|
|
.send()
|
|
.await
|
|
.expect("search");
|
|
assert_eq!(response.status(), StatusCode::ACCEPTED);
|
|
let season_id = season["id"].as_i64().expect("season id");
|
|
assert_eq!(
|
|
state.next_season_command().await.expect("command"),
|
|
SeasonCommand::Search { season_id }
|
|
);
|
|
|
|
// A stale stored score proves the deck is rescored at read time,
|
|
// like the movie deck (#114).
|
|
let pool = state.database().expect("database").pool();
|
|
let name = "Bluey S01 1080p WEB-DL x264-GROUP";
|
|
let parsed = arr_parse::parse(name);
|
|
let release_id = sqlx::query_scalar::<_, i64>(
|
|
"INSERT INTO releases (indexer_id, guid, name, size, seeders, download_url, parsed, score, verdict)
|
|
VALUES (7, 'pack', ?, 1000, 50, 'url', ?, -12345, 'eligible') RETURNING id",
|
|
)
|
|
.bind(name)
|
|
.bind(serde_json::to_string(&parsed).expect("parsed json"))
|
|
.fetch_one(pool)
|
|
.await
|
|
.expect("release");
|
|
|
|
sqlx::query("INSERT INTO season_releases (season_id, release_id) VALUES (?, ?)")
|
|
.bind(season_id)
|
|
.bind(release_id)
|
|
.execute(pool)
|
|
.await
|
|
.expect("association");
|
|
|
|
let releases: Vec<serde_json::Value> =
|
|
reqwest::get(format!("{base}/api/series/{series_id}/seasons/1/releases"))
|
|
.await
|
|
.expect("releases")
|
|
.json()
|
|
.await
|
|
.expect("releases json");
|
|
assert_eq!(releases.len(), 1);
|
|
assert_eq!(releases[0]["verdict"], "eligible");
|
|
assert_ne!(
|
|
releases[0]["score"].as_f64(),
|
|
Some(-12345.0),
|
|
"the deck reflects the current policy, not the stored score"
|
|
);
|
|
|
|
let response = reqwest::Client::new()
|
|
.post(format!(
|
|
"{base}/api/series/{series_id}/seasons/1/releases/{release_id}/grab"
|
|
))
|
|
.send()
|
|
.await
|
|
.expect("grab");
|
|
assert_eq!(response.status(), StatusCode::ACCEPTED);
|
|
assert_eq!(
|
|
state.next_season_command().await.expect("command"),
|
|
SeasonCommand::Grab {
|
|
season_id,
|
|
release_id
|
|
}
|
|
);
|
|
|
|
// A release belonging to another season is not grabbable through
|
|
// this one, and an unknown season number is not another season.
|
|
let other = sqlx::query_scalar::<_, i64>("INSERT INTO releases (indexer_id, guid, name, size, download_url, parsed, verdict) VALUES (7, 'other', 'other', 1, 'url', '{}', 'eligible') RETURNING id")
|
|
.fetch_one(pool)
|
|
.await
|
|
.expect("other release");
|
|
let response = reqwest::Client::new()
|
|
.post(format!(
|
|
"{base}/api/series/{series_id}/seasons/1/releases/{other}/grab"
|
|
))
|
|
.send()
|
|
.await
|
|
.expect("grab");
|
|
assert_eq!(response.status(), StatusCode::NOT_FOUND);
|
|
let response = reqwest::get(format!("{base}/api/series/{series_id}/seasons/2/releases"))
|
|
.await
|
|
.expect("unknown season");
|
|
assert_eq!(response.status(), StatusCode::NOT_FOUND);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_blocked_series_refuses_a_season_search() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, false).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "Pilot"}]),
|
|
)
|
|
.await;
|
|
reqwest::Client::new()
|
|
.patch(format!("{base}/api/series/{series_id}"))
|
|
.json(&serde_json::json!({"blocked": true}))
|
|
.send()
|
|
.await
|
|
.expect("block the series");
|
|
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series/{series_id}/seasons/1/search"))
|
|
.send()
|
|
.await
|
|
.expect("blocked search");
|
|
assert_eq!(response.status(), StatusCode::CONFLICT);
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn owner_tags_filter_the_series_list() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "kids").await;
|
|
let series = add_series(&base, root_id, true).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let owner_id = sqlx::query_scalar::<_, i64>(
|
|
"INSERT INTO owners (name, ntfy_topic) VALUES ('kid', 'arr-kid') RETURNING id",
|
|
)
|
|
.fetch_one(state.database().expect("database").pool())
|
|
.await
|
|
.expect("owner");
|
|
|
|
let empty: Vec<serde_json::Value> =
|
|
reqwest::get(format!("{base}/api/series?owner_id={owner_id}"))
|
|
.await
|
|
.expect("filtered list")
|
|
.json()
|
|
.await
|
|
.expect("json");
|
|
assert!(empty.is_empty());
|
|
|
|
let tagged = reqwest::Client::new()
|
|
.put(format!("{base}/api/series/{series_id}/owners/{owner_id}"))
|
|
.send()
|
|
.await
|
|
.expect("tag");
|
|
assert_eq!(tagged.status(), StatusCode::NO_CONTENT);
|
|
|
|
let filtered: Vec<serde_json::Value> =
|
|
reqwest::get(format!("{base}/api/series?owner_id={owner_id}"))
|
|
.await
|
|
.expect("filtered list")
|
|
.json()
|
|
.await
|
|
.expect("json");
|
|
assert_eq!(filtered.len(), 1);
|
|
assert_eq!(filtered[0]["id"], series_id);
|
|
|
|
let owners: Vec<serde_json::Value> =
|
|
reqwest::get(format!("{base}/api/series/{series_id}/owners"))
|
|
.await
|
|
.expect("owners")
|
|
.json()
|
|
.await
|
|
.expect("json");
|
|
assert_eq!(owners.len(), 1);
|
|
|
|
reqwest::Client::new()
|
|
.delete(format!("{base}/api/series/{series_id}/owners/{owner_id}"))
|
|
.send()
|
|
.await
|
|
.expect("untag");
|
|
let owners: Vec<serde_json::Value> =
|
|
reqwest::get(format!("{base}/api/series/{series_id}/owners"))
|
|
.await
|
|
.expect("owners")
|
|
.json()
|
|
.await
|
|
.expect("json");
|
|
assert!(owners.is_empty());
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn deleting_a_series_takes_its_seasons_and_episodes() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, true).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "Pilot", "air_date": "2001-01-01"}]),
|
|
)
|
|
.await;
|
|
|
|
let response = reqwest::Client::new()
|
|
.delete(format!("{base}/api/series/{series_id}"))
|
|
.send()
|
|
.await
|
|
.expect("delete");
|
|
assert_eq!(response.status(), StatusCode::NO_CONTENT);
|
|
|
|
let episodes: i64 = sqlx::query_scalar("SELECT count(*) FROM episodes")
|
|
.fetch_one(state.database().expect("database").pool())
|
|
.await
|
|
.expect("count episodes");
|
|
assert_eq!(episodes, 0);
|
|
}
|
|
|
|
/// A series on disk for one test: the §7.4 title folder with a season
|
|
/// subfolder holding one episode file and one sidecar subtitle.
|
|
async fn library_on_disk(
|
|
state: &AppState,
|
|
episode_id: i64,
|
|
root: &std::path::Path,
|
|
) -> std::path::PathBuf {
|
|
let folder = root.join("Bluey (2018) [tmdbid-82728]");
|
|
let season = folder.join("Season 01");
|
|
tokio::fs::create_dir_all(&season)
|
|
.await
|
|
.expect("create title folder");
|
|
let feature = season.join("Bluey (2018) - S01E01 - Pilot [1080p][WEB-DL].mkv");
|
|
tokio::fs::write(&feature, b"episode").await.expect("write");
|
|
tokio::fs::write(season.join("bluey.s01e01.pt.srt"), b"subs")
|
|
.await
|
|
.expect("write sidecar");
|
|
|
|
let pool = state.database().expect("database").pool();
|
|
let root_path = root.to_str().expect("utf-8 root");
|
|
sqlx::query("UPDATE roots SET path = ? WHERE kind = 'tv' AND audience = 'main'")
|
|
.bind(root_path)
|
|
.execute(pool)
|
|
.await
|
|
.expect("point the root at the tempdir");
|
|
sqlx::query(
|
|
"INSERT INTO media_files (owner_kind, owner_id, path, size) VALUES ('episode', ?, ?, 7)",
|
|
)
|
|
.bind(episode_id)
|
|
.bind(feature.to_str().expect("utf-8 path"))
|
|
.execute(pool)
|
|
.await
|
|
.expect("media file");
|
|
folder
|
|
}
|
|
|
|
/// The §7.4 title folder is the unit of deletion, so the season
|
|
/// subfolder and sidecars go with it — and the root is never touched.
|
|
#[tokio::test]
|
|
async fn deleting_a_series_removes_the_whole_title_folder() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, true).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "Pilot", "air_date": "2001-01-01"}]),
|
|
)
|
|
.await;
|
|
let episode_id = season["episodes"][0]["id"].as_i64().expect("episode id");
|
|
let root = tempfile::tempdir().expect("root");
|
|
let folder = library_on_disk(&state, episode_id, root.path()).await;
|
|
|
|
let response = reqwest::Client::new()
|
|
.delete(format!("{base}/api/series/{series_id}"))
|
|
.send()
|
|
.await
|
|
.expect("delete");
|
|
assert_eq!(response.status(), StatusCode::NO_CONTENT);
|
|
assert!(
|
|
!folder.exists(),
|
|
"the title folder, its seasons and its sidecars are gone"
|
|
);
|
|
assert!(root.path().exists(), "the root survives its titles");
|
|
|
|
let pool = state.database().expect("database").pool();
|
|
let orphans: i64 =
|
|
sqlx::query_scalar("SELECT count(*) FROM media_files WHERE owner_kind = 'episode'")
|
|
.fetch_one(pool)
|
|
.await
|
|
.expect("count files");
|
|
assert_eq!(orphans, 0, "the file rows go with the files");
|
|
}
|
|
|
|
/// A missing series is 404 before anything touches the disk.
|
|
#[tokio::test]
|
|
async fn deleting_a_missing_series_is_a_404() {
|
|
let (_dir, _state, base) = application().await;
|
|
let response = reqwest::Client::new()
|
|
.delete(format!("{base}/api/series/999"))
|
|
.send()
|
|
.await
|
|
.expect("delete");
|
|
assert_eq!(response.status(), StatusCode::NOT_FOUND);
|
|
}
|
|
|
|
/// The detail view reads its episode files through the series, keyed by
|
|
/// episode id, so one request carries every §7.4 attribute tag it shows.
|
|
#[tokio::test]
|
|
async fn series_files_are_keyed_by_episode() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "kids").await;
|
|
let series = add_series(&base, root_id, true).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([
|
|
{"number": 1, "title": "The Magic Xylophone", "air_date": "2018-10-01"},
|
|
{"number": 2, "title": "Hospital", "air_date": "2018-10-02"}
|
|
]),
|
|
)
|
|
.await;
|
|
let episodes = season["episodes"].as_array().expect("episodes");
|
|
let first = episodes[0]["id"].as_i64().expect("episode id");
|
|
let pool = state.database().expect("database").pool();
|
|
sqlx::query(
|
|
r"INSERT INTO media_files (owner_kind, owner_id, path, size, probed, waiver)
|
|
VALUES ('episode', ?, ?, 7, ?, ?)",
|
|
)
|
|
.bind(first)
|
|
.bind("/mnt/media/tv/kids/Bluey (2018) [tmdbid-82728]/Season 01/Bluey S01E01.mkv")
|
|
.bind(r#"{"resolution":"1080p","source":null,"hdr":"SDR","audio_tracks":[{"language":"pt-PT","title":null,"handler_name":null}],"sub_tracks":[]}"#)
|
|
.bind(r#"{"rule":"required_audio"}"#)
|
|
.execute(pool)
|
|
.await
|
|
.expect("media file");
|
|
|
|
let response = reqwest::get(format!("{base}/api/series/{series_id}/files"))
|
|
.await
|
|
.expect("fetch files");
|
|
assert_eq!(response.status(), StatusCode::OK);
|
|
let files: serde_json::Value = response.json().await.expect("files json");
|
|
let rows = files.as_array().expect("array");
|
|
assert_eq!(rows.len(), 1, "only imported episodes carry a file");
|
|
assert_eq!(rows[0]["episode_id"], first);
|
|
assert_eq!(rows[0]["probed"]["resolution"], "1080p");
|
|
assert_eq!(rows[0]["probed"]["audio_tracks"][0]["language"], "pt-PT");
|
|
assert_eq!(rows[0]["waiver"], "required_audio");
|
|
|
|
let missing = reqwest::get(format!("{base}/api/series/999/files"))
|
|
.await
|
|
.expect("fetch files");
|
|
assert_eq!(missing.status(), StatusCode::NOT_FOUND);
|
|
}
|
|
|
|
/// The guard that keeps a delete inside the library: a path that is not
|
|
/// under the series' root is left alone, whatever the row says.
|
|
#[tokio::test]
|
|
async fn a_series_file_outside_its_root_is_never_unlinked() {
|
|
let (_dir, state, base) = application().await;
|
|
let root_id = tv_root(&state, "main").await;
|
|
let series = add_series(&base, root_id, true).await;
|
|
let series_id = series["id"].as_i64().expect("id");
|
|
let season = add_season(
|
|
&base,
|
|
series_id,
|
|
1,
|
|
serde_json::json!([{"number": 1, "title": "Pilot"}]),
|
|
)
|
|
.await;
|
|
let episode_id = season["episodes"][0]["id"].as_i64().expect("episode id");
|
|
|
|
let root = tempfile::tempdir().expect("root");
|
|
sqlx::query("UPDATE roots SET path = ? WHERE id = ?")
|
|
.bind(root.path().to_str().expect("utf-8 root"))
|
|
.bind(root_id)
|
|
.execute(state.database().expect("database").pool())
|
|
.await
|
|
.expect("point the root at the tempdir");
|
|
|
|
let elsewhere = tempfile::tempdir().expect("elsewhere");
|
|
let stray = elsewhere.path().join("not-ours.mkv");
|
|
tokio::fs::write(&stray, b"stray").await.expect("write");
|
|
sqlx::query(
|
|
"INSERT INTO media_files (owner_kind, owner_id, path, size) VALUES ('episode', ?, ?, 5)",
|
|
)
|
|
.bind(episode_id)
|
|
.bind(stray.to_str().expect("utf-8 path"))
|
|
.execute(state.database().expect("database").pool())
|
|
.await
|
|
.expect("media file");
|
|
|
|
let response = reqwest::Client::new()
|
|
.delete(format!("{base}/api/series/{series_id}"))
|
|
.send()
|
|
.await
|
|
.expect("delete");
|
|
assert_eq!(response.status(), StatusCode::NO_CONTENT);
|
|
assert!(
|
|
stray.exists(),
|
|
"a path outside the root is not ours to delete"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn air_dates_parse_as_dates_and_as_timestamps() {
|
|
assert_eq!(
|
|
air_date(Some("1970-01-02")),
|
|
Some(UNIX_EPOCH + Duration::from_hours(24))
|
|
);
|
|
assert_eq!(
|
|
air_date(Some("1970-01-02T00:00:00Z")),
|
|
Some(UNIX_EPOCH + Duration::from_hours(24))
|
|
);
|
|
assert_eq!(air_date(Some("not a date")), None);
|
|
assert_eq!(air_date(None), None);
|
|
}
|
|
}
|