Miguel Palhas
450 lines
17 KiB
Rust
450 lines
17 KiB
Rust
//! Title detail metadata for the §9.6 pages (#146). One endpoint per kind,
|
|
//! one upstream call each through `arr-meta`'s detail methods, cached 24h and
|
|
//! never persisted. Library titles only: search rows already carry what a
|
|
//! results list needs.
|
|
|
|
use arr_meta::{MovieDetail, SeriesDetail};
|
|
use axum::extract::{Path, State};
|
|
use axum::Json;
|
|
use serde::Serialize;
|
|
use utoipa::ToSchema;
|
|
|
|
use crate::movies::{pool, ApiError, ErrorBody};
|
|
use crate::search::{tmdb_client, upstream_error};
|
|
use crate::state::AppState;
|
|
|
|
/// One of the top-billed cast members on a detail page.
|
|
#[derive(Debug, Clone, Serialize, ToSchema)]
|
|
pub struct MetadataCastMember {
|
|
/// The person's TMDB id, for the link out to tmdb.org (§9.6).
|
|
pub tmdb_id: u32,
|
|
pub name: String,
|
|
pub character: String,
|
|
/// Path fragment exactly as TMDB sends it (§9.6): the browser composes
|
|
/// the URL and picks the size.
|
|
pub profile_path: Option<String>,
|
|
}
|
|
|
|
/// The one trailer worth showing, resolved by the §9.6 rule inside `arr-meta`.
|
|
#[derive(Debug, Clone, Serialize, ToSchema)]
|
|
pub struct MetadataTrailer {
|
|
pub youtube_key: String,
|
|
pub name: String,
|
|
}
|
|
|
|
/// Rich detail for one library movie's §9.6 page. Image paths are fragments,
|
|
/// never composed URLs; the Rotten Tomatoes link is deliberately absent — it
|
|
/// is a browser-built search URL, not an identifier this service holds.
|
|
#[derive(Debug, Clone, Serialize, ToSchema)]
|
|
pub struct MovieMetadata {
|
|
pub tmdb_id: u32,
|
|
pub overview: Option<String>,
|
|
pub tagline: Option<String>,
|
|
pub genres: Vec<String>,
|
|
/// Minutes.
|
|
pub runtime: Option<u32>,
|
|
pub status: String,
|
|
pub poster_path: Option<String>,
|
|
pub backdrop_path: Option<String>,
|
|
pub vote_average: f64,
|
|
pub vote_count: u32,
|
|
pub homepage: Option<String>,
|
|
/// §9.6 links out to `IMDb` for movies.
|
|
pub imdb_id: Option<String>,
|
|
/// Top 10 billed, ordered by TMDB's own cast order.
|
|
pub cast: Vec<MetadataCastMember>,
|
|
pub trailer: Option<MetadataTrailer>,
|
|
}
|
|
|
|
/// Rich detail for one library series' §9.6 page.
|
|
#[derive(Debug, Clone, Serialize, ToSchema)]
|
|
pub struct SeriesMetadata {
|
|
pub tmdb_id: u32,
|
|
pub overview: Option<String>,
|
|
pub tagline: Option<String>,
|
|
pub genres: Vec<String>,
|
|
/// Episode length in minutes.
|
|
pub runtime: Option<u32>,
|
|
pub status: String,
|
|
pub poster_path: Option<String>,
|
|
pub backdrop_path: Option<String>,
|
|
pub vote_average: f64,
|
|
pub vote_count: u32,
|
|
pub homepage: Option<String>,
|
|
/// §9.6 links out to TVDB for series.
|
|
pub tvdb_id: Option<u32>,
|
|
/// Top 10 billed, ordered by TMDB's own cast order.
|
|
pub cast: Vec<MetadataCastMember>,
|
|
pub trailer: Option<MetadataTrailer>,
|
|
}
|
|
|
|
impl From<MovieDetail> for MovieMetadata {
|
|
fn from(detail: MovieDetail) -> Self {
|
|
Self {
|
|
tmdb_id: detail.tmdb_id,
|
|
overview: detail.overview,
|
|
tagline: detail.tagline,
|
|
genres: detail.genres.into_iter().map(|genre| genre.name).collect(),
|
|
runtime: detail.runtime,
|
|
status: detail.status,
|
|
poster_path: detail.poster_path,
|
|
backdrop_path: detail.backdrop_path,
|
|
vote_average: detail.vote_average,
|
|
vote_count: detail.vote_count,
|
|
homepage: detail.homepage,
|
|
imdb_id: detail.imdb_id,
|
|
cast: detail.cast.into_iter().map(Into::into).collect(),
|
|
trailer: detail.trailer.map(Into::into),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<SeriesDetail> for SeriesMetadata {
|
|
fn from(detail: SeriesDetail) -> Self {
|
|
Self {
|
|
tmdb_id: detail.tmdb_id,
|
|
overview: detail.overview,
|
|
tagline: detail.tagline,
|
|
genres: detail.genres.into_iter().map(|genre| genre.name).collect(),
|
|
runtime: detail.episode_runtime,
|
|
status: detail.status,
|
|
poster_path: detail.poster_path,
|
|
backdrop_path: detail.backdrop_path,
|
|
vote_average: detail.vote_average,
|
|
vote_count: detail.vote_count,
|
|
homepage: detail.homepage,
|
|
tvdb_id: detail.tvdb_id,
|
|
cast: detail.cast.into_iter().map(Into::into).collect(),
|
|
trailer: detail.trailer.map(Into::into),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<arr_meta::CastMember> for MetadataCastMember {
|
|
fn from(member: arr_meta::CastMember) -> Self {
|
|
Self {
|
|
tmdb_id: member.tmdb_id,
|
|
name: member.name,
|
|
character: member.character,
|
|
profile_path: member.profile_path,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl From<arr_meta::Video> for MetadataTrailer {
|
|
fn from(video: arr_meta::Video) -> Self {
|
|
Self {
|
|
youtube_key: video.key,
|
|
name: video.name,
|
|
}
|
|
}
|
|
}
|
|
|
|
fn tmdb_id(raw: i64) -> Result<u32, ApiError> {
|
|
u32::try_from(raw).map_err(|_| ApiError::Invalid("stored tmdb_id is out of range".into()))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/movies/{movie_id}/metadata", tag = "movies",
|
|
params(("movie_id" = i64, Path, description = "Movie row id")),
|
|
responses(
|
|
(status = 200, body = MovieMetadata),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 422, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn movie_metadata(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<Json<MovieMetadata>, ApiError> {
|
|
let tmdb_row = sqlx::query_scalar!("SELECT tmdb_id FROM movies WHERE id = ?", id)
|
|
.fetch_one(pool(&state)?)
|
|
.await?;
|
|
let tmdb = tmdb_client(&state)?;
|
|
let detail = tmdb
|
|
.movie_detail(tmdb_id(tmdb_row)?)
|
|
.await
|
|
.map_err(|error| upstream_error(&error))?;
|
|
Ok(Json(detail.into()))
|
|
}
|
|
|
|
#[utoipa::path(
|
|
get, path = "/api/series/{series_id}/metadata", tag = "series",
|
|
params(("series_id" = i64, Path, description = "Series row id")),
|
|
responses(
|
|
(status = 200, body = SeriesMetadata),
|
|
(status = 404, body = ErrorBody),
|
|
(status = 422, body = ErrorBody),
|
|
(status = 500, body = ErrorBody),
|
|
(status = 503, body = ErrorBody)
|
|
)
|
|
)]
|
|
pub async fn series_metadata(
|
|
State(state): State<AppState>,
|
|
Path(id): Path<i64>,
|
|
) -> Result<Json<SeriesMetadata>, ApiError> {
|
|
let tmdb_row = sqlx::query_scalar!("SELECT tmdb_id FROM series WHERE id = ?", id)
|
|
.fetch_one(pool(&state)?)
|
|
.await
|
|
.map_err(|error| {
|
|
if matches!(error, sqlx::Error::RowNotFound) {
|
|
ApiError::SeriesNotFound
|
|
} else {
|
|
error.into()
|
|
}
|
|
})?;
|
|
let tmdb = tmdb_client(&state)?;
|
|
let detail = tmdb
|
|
.series_detail(tmdb_id(tmdb_row)?)
|
|
.await
|
|
.map_err(|error| upstream_error(&error))?;
|
|
Ok(Json(detail.into()))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::{router, Upstreams};
|
|
use wiremock::matchers::{method, path};
|
|
use wiremock::{Mock, MockServer, ResponseTemplate};
|
|
|
|
/// App against a mocked TMDB, with a real migrated database so library
|
|
/// rows exist to resolve local ids against.
|
|
async fn application(tmdb: &MockServer) -> (tempfile::TempDir, 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())
|
|
.with_tmdb_url(tmdb.uri())
|
|
.with_tmdb_api_key(Some("tmdb-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");
|
|
tokio::spawn(async move { axum::serve(listener, router(state)).await.expect("serve") });
|
|
(dir, format!("http://{address}"))
|
|
}
|
|
|
|
async fn add_movie(base: &str) -> serde_json::Value {
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/movies"))
|
|
.json(&serde_json::json!({
|
|
"tmdb_id": 693_134, "title": "Dune Part Two", "year": 2024,
|
|
"original_language": "en", "root_id": 1
|
|
}))
|
|
.send()
|
|
.await
|
|
.expect("create movie");
|
|
assert_eq!(response.status(), 201);
|
|
response.json().await.expect("movie json")
|
|
}
|
|
|
|
async fn add_series(base: &str) -> serde_json::Value {
|
|
let roots: Vec<serde_json::Value> = reqwest::get(format!("{base}/api/roots"))
|
|
.await
|
|
.expect("roots")
|
|
.json()
|
|
.await
|
|
.expect("roots json");
|
|
let tv_root = roots
|
|
.iter()
|
|
.find(|root| root["kind"] == "tv")
|
|
.and_then(|root| root["id"].as_i64())
|
|
.expect("a seeded TV root");
|
|
let response = reqwest::Client::new()
|
|
.post(format!("{base}/api/series"))
|
|
.json(&serde_json::json!({
|
|
"tmdb_id": 82_728, "title": "The Last of Us",
|
|
"original_language": "en", "root_id": tv_root
|
|
}))
|
|
.send()
|
|
.await
|
|
.expect("create series");
|
|
assert_eq!(response.status(), 201);
|
|
response.json().await.expect("series json")
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_movie_metadata_resolves_through_one_detail_call() {
|
|
let tmdb = MockServer::start().await;
|
|
Mock::given(method("GET"))
|
|
.and(path("/movie/693134"))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
|
|
"id": 693_134,
|
|
"overview": "Paul Atreides unites with the Fremen.",
|
|
"tagline": "Long live the fighters.",
|
|
"genres": [{"id": 878, "name": "Science Fiction"}, {"id": 12, "name": "Adventure"}],
|
|
"backdrop_path": "/xOMo8BRK7PfcJv9JCnx7s5hj0PX.jpg",
|
|
"poster_path": "/1pdfLlvXA5qYN3ikFm4QDe7EJ19.jpg",
|
|
"vote_average": 8.417,
|
|
"vote_count": 3_512,
|
|
"homepage": "https://www.duneparttwo.com",
|
|
"status": "Released",
|
|
"runtime": 166,
|
|
"imdb_id": "tt15239678",
|
|
"credits": {"cast": [
|
|
{"id": 9_058_792, "name": "Timothée Chalamet", "character": "Paul Atreides",
|
|
"profile_path": "/tzLq0VAm3myi2lzNpdfhVGjXAdB.jpg", "order": 0},
|
|
{"id": 1_320_062, "name": "Zendaya", "character": "Chani",
|
|
"profile_path": "/ultRzqcGdWXWX3rjg1up9HcsoGi.jpg", "order": 1}
|
|
]},
|
|
"videos": {"results": [
|
|
{"key": "fan_edit", "site": "YouTube", "type": "Trailer",
|
|
"name": "Fan Trailer", "official": false},
|
|
{"key": "Way9Dexny3w", "site": "YouTube", "type": "Trailer",
|
|
"name": "Dune: Part Two | Official Trailer", "official": true}
|
|
]}
|
|
})))
|
|
.expect(1)
|
|
.mount(&tmdb)
|
|
.await;
|
|
let (_dir, base) = application(&tmdb).await;
|
|
let movie = add_movie(&base).await;
|
|
let movie_id = movie["id"].as_i64().expect("movie id");
|
|
|
|
let body: serde_json::Value =
|
|
reqwest::get(format!("{base}/api/movies/{movie_id}/metadata"))
|
|
.await
|
|
.expect("request")
|
|
.json()
|
|
.await
|
|
.expect("json");
|
|
|
|
assert_eq!(body["tmdb_id"], 693_134);
|
|
assert_eq!(body["overview"], "Paul Atreides unites with the Fremen.");
|
|
assert_eq!(body["tagline"], "Long live the fighters.");
|
|
assert_eq!(body["genres"][0], "Science Fiction");
|
|
assert_eq!(body["runtime"], 166);
|
|
assert_eq!(body["status"], "Released");
|
|
assert_eq!(body["imdb_id"], "tt15239678");
|
|
assert_eq!(body["vote_average"], serde_json::json!(8.417));
|
|
assert_eq!(body["vote_count"], 3_512);
|
|
// §9.6: path fragments exactly as TMDB sends them, never composed URLs.
|
|
assert_eq!(body["poster_path"], "/1pdfLlvXA5qYN3ikFm4QDe7EJ19.jpg");
|
|
assert_eq!(body["backdrop_path"], "/xOMo8BRK7PfcJv9JCnx7s5hj0PX.jpg");
|
|
assert_eq!(
|
|
body["cast"][0]["profile_path"],
|
|
"/tzLq0VAm3myi2lzNpdfhVGjXAdB.jpg"
|
|
);
|
|
assert_eq!(body["cast"][0]["character"], "Paul Atreides");
|
|
assert_eq!(body["trailer"]["youtube_key"], "Way9Dexny3w");
|
|
tmdb.verify().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn a_series_metadata_carries_the_tvdb_id_and_episode_runtime() {
|
|
let tmdb = MockServer::start().await;
|
|
Mock::given(method("GET"))
|
|
.and(path("/tv/82728"))
|
|
.respond_with(ResponseTemplate::new(200).set_body_json(serde_json::json!({
|
|
"id": 82_728,
|
|
"overview": "Twenty years after civilization fell.",
|
|
"tagline": "When you're lost in the darkness, look for the light.",
|
|
"genres": [{"id": 18, "name": "Drama"}],
|
|
"backdrop_path": "/eMhDKZscBd07OLpAeeAyu3N3U8c.jpg",
|
|
"poster_path": "/uKvVjHNqB5VmOrdxqAt2F7J78ED.jpg",
|
|
"vote_average": 8.5,
|
|
"vote_count": 2_911,
|
|
"homepage": "",
|
|
"status": "Returning Series",
|
|
"episode_run_time": [55, 57],
|
|
"external_ids": {"tvdb_id": 392_256},
|
|
"credits": {"cast": [
|
|
{"id": 1_320_062, "name": "Pedro Pascal", "character": "Joel Miller",
|
|
"profile_path": "/zEmkctzuGBEbxFfOtpTAg9jtkTu.jpg", "order": 0}
|
|
]},
|
|
"videos": {"results": [
|
|
{"key": "uLtkt8Bonuu", "site": "YouTube", "type": "Trailer",
|
|
"name": "Official Trailer", "official": true}
|
|
]}
|
|
})))
|
|
.mount(&tmdb)
|
|
.await;
|
|
let (_dir, base) = application(&tmdb).await;
|
|
let series = add_series(&base).await;
|
|
let series_id = series["id"].as_i64().expect("series id");
|
|
|
|
let body: serde_json::Value =
|
|
reqwest::get(format!("{base}/api/series/{series_id}/metadata"))
|
|
.await
|
|
.expect("request")
|
|
.json()
|
|
.await
|
|
.expect("json");
|
|
|
|
assert_eq!(body["tmdb_id"], 82_728);
|
|
assert_eq!(body["tvdb_id"], 392_256);
|
|
// TMDB sends a list of episode lengths; the API reports one runtime.
|
|
assert_eq!(body["runtime"], 55);
|
|
assert_eq!(body["status"], "Returning Series");
|
|
// TMDB uses "" where null is meant; it stays null on the way out.
|
|
assert_eq!(body["homepage"], serde_json::Value::Null);
|
|
assert_eq!(body["poster_path"], "/uKvVjHNqB5VmOrdxqAt2F7J78ED.jpg");
|
|
assert_eq!(body["trailer"]["youtube_key"], "uLtkt8Bonuu");
|
|
}
|
|
|
|
/// An id that is not in the library is a 404 before TMDB is asked —
|
|
/// search rows are addressed through #144's trailer endpoint instead.
|
|
#[tokio::test]
|
|
async fn an_unknown_local_id_is_a_forty_forty_without_touching_tmdb() {
|
|
let tmdb = MockServer::start().await;
|
|
let (_dir, base) = application(&tmdb).await;
|
|
|
|
let movie = reqwest::get(format!("{base}/api/movies/99/metadata"))
|
|
.await
|
|
.expect("request");
|
|
assert_eq!(movie.status(), 404);
|
|
assert_eq!(
|
|
movie.json::<serde_json::Value>().await.expect("json")["error"],
|
|
"movie not found"
|
|
);
|
|
|
|
let series = reqwest::get(format!("{base}/api/series/99/metadata"))
|
|
.await
|
|
.expect("request");
|
|
assert_eq!(series.status(), 404);
|
|
assert_eq!(
|
|
series.json::<serde_json::Value>().await.expect("json")["error"],
|
|
"series not found"
|
|
);
|
|
tmdb.verify().await;
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn no_tmdb_key_is_a_fifty_three_like_the_rest_of_the_surface() {
|
|
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");
|
|
tokio::spawn(async move { axum::serve(listener, router(state)).await.expect("serve") });
|
|
let base = format!("http://{address}");
|
|
|
|
let movie = add_movie(&base).await;
|
|
let movie_id = movie["id"].as_i64().expect("movie id");
|
|
|
|
let response = reqwest::get(format!("{base}/api/movies/{movie_id}/metadata"))
|
|
.await
|
|
.expect("request");
|
|
assert_eq!(response.status(), 503);
|
|
}
|
|
}
|