Spaces:
Paused
Paused
PNRxA commited on
Commit ·
0b7bef2
1
Parent(s): dee5c19
expose all customisation through url params, fixes #3
Browse files- README.md +12 -1
- api/src/handlers/admin.rs +3 -3
- api/src/handlers/api_keys.rs +3 -3
- api/src/handlers/image.rs +272 -5
- api/src/handlers/preview.rs +108 -77
- api/src/image/generate.rs +122 -22
- api/src/image/serve.rs +19 -18
- api/src/lib.rs +4 -0
- api/src/services/db.rs +251 -41
- api/tests/db_operations.rs +2 -2
- api/tests/e2e_settings.rs +514 -0
- api/tests/preview.rs +300 -4
- api/tests/query_overrides.rs +260 -0
- scripts/regenerate-examples.sh +1 -1
- scripts/test.sh +1 -0
- web/src/__tests__/components/FreeApiKeyCard.spec.ts +56 -27
- web/src/__tests__/components/RatingsOrderList.spec.ts +149 -0
- web/src/__tests__/lib/api-self.spec.ts +8 -2
- web/src/__tests__/lib/api.spec.ts +4 -4
- web/src/__tests__/lib/constants.spec.ts +68 -0
- web/src/components/FreeApiKeyCard.vue +170 -40
- web/src/components/RatingsOrderList.vue +55 -0
- web/src/components/RenderSettingsForm.vue +5 -63
- web/src/lib/api.ts +2 -2
- web/src/lib/constants.ts +22 -0
README.md
CHANGED
|
@@ -87,8 +87,19 @@ GET /{api_key}/isValid
|
|
| 87 |
- `?fallback=true`: accepted for RPDB plugin compatibility but ignored as OPDB falls back to TMDB by default
|
| 88 |
- `?lang={code}`: override the Fanart.tv language for this request (e.g. `?lang=de` for German posters). Automatically switches the poster source to Fanart.tv even if TMDB is configured
|
| 89 |
- `?imageSize={size}`: control output image dimensions. Available sizes vary by image type (see [Image Sizes](#image-sizes))
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 90 |
- RPDB-compatible — use `http://localhost:3000` as the base URL (drop-in replacement for `https://api.ratingposterdb.com`)
|
| 91 |
|
|
|
|
|
|
|
| 92 |
Management endpoints (auth, keys, settings) are under `/api/` and return JSON.
|
| 93 |
|
| 94 |
### Image Sizes
|
|
@@ -302,7 +313,7 @@ Settings are stored as short single-character or two-character codes:
|
|
| 302 |
| `label_style` | `t`, `i`, `o` | Text, Icon, Official |
|
| 303 |
| `badge_direction` | `d`, `h`, `v` | Default (auto-resolved by position), Horizontal, Vertical |
|
| 304 |
| `badge_size` | `xs`, `s`, `m`, `l`, `xl` | Extra-small (0.5×), Small (0.75×), Medium (1.0×), Large (1.25×), Extra-large (1.5×) |
|
| 305 |
-
| `
|
| 306 |
|
| 307 |
### Example Cache Keys
|
| 308 |
|
|
|
|
| 87 |
- `?fallback=true`: accepted for RPDB plugin compatibility but ignored as OPDB falls back to TMDB by default
|
| 88 |
- `?lang={code}`: override the Fanart.tv language for this request (e.g. `?lang=de` for German posters). Automatically switches the poster source to Fanart.tv even if TMDB is configured
|
| 89 |
- `?imageSize={size}`: control output image dimensions. Available sizes vary by image type (see [Image Sizes](#image-sizes))
|
| 90 |
+
- `?ratings_limit={0-8}`: maximum number of rating badges to display
|
| 91 |
+
- `?ratings_order={keys}`: comma-separated rating source keys controlling display order. Valid keys: `imdb`, `tmdb`, `rt` (RT Critics), `rta` (RT Audience), `mc` (Metacritic), `trakt`, `lb` (Letterboxd), `mal` (MyAnimeList). Example: `?ratings_order=imdb,tmdb,rt`
|
| 92 |
+
- `?badge_style={h|v|d}`: badge layout — `h` (horizontal), `v` (vertical), `d` (default)
|
| 93 |
+
- `?label_style={t|i|o}`: label rendering — `t` (text), `i` (icon), `o` (official provider logos)
|
| 94 |
+
- `?badge_size={xs|s|m|l|xl}`: badge scale — extra-small, small, medium, large, extra-large
|
| 95 |
+
- `?badge_direction={d|h|v}`: badge stacking direction (poster only) — `d` (default), `h` (horizontal), `v` (vertical)
|
| 96 |
+
- `?position={bc|tc|l|r|tl|tr|bl|br}`: badge anchor position (poster only)
|
| 97 |
+
- `?poster_source={t|f}`: poster image source (poster only) — `t` (TMDB), `f` (Fanart.tv)
|
| 98 |
+
- `?fanart_textless={true|false}`: use textless Fanart.tv posters when available (poster only)
|
| 99 |
- RPDB-compatible — use `http://localhost:3000` as the base URL (drop-in replacement for `https://api.ratingposterdb.com`)
|
| 100 |
|
| 101 |
+
Poster-only parameters (`badge_direction`, `position`, `poster_source`, `fanart_textless`) are silently ignored on logo and backdrop endpoints. For shared parameters (`ratings_limit`, `badge_style`, `label_style`, `badge_size`), the override is applied to the correct image-type-specific setting (e.g. `?badge_style=h` on the poster endpoint sets `poster_badge_style`, on the logo endpoint sets `logo_badge_style`).
|
| 102 |
+
|
| 103 |
Management endpoints (auth, keys, settings) are under `/api/` and return JSON.
|
| 104 |
|
| 105 |
### Image Sizes
|
|
|
|
| 313 |
| `label_style` | `t`, `i`, `o` | Text, Icon, Official |
|
| 314 |
| `badge_direction` | `d`, `h`, `v` | Default (auto-resolved by position), Horizontal, Vertical |
|
| 315 |
| `badge_size` | `xs`, `s`, `m`, `l`, `xl` | Extra-small (0.5×), Small (0.75×), Medium (1.0×), Large (1.25×), Extra-large (1.5×) |
|
| 316 |
+
| `position` | `bc`, `tc`, `l`, `r`, `tl`, `tr`, `bl`, `br` | Bottom-center, Top-center, Left, Right, corners |
|
| 317 |
|
| 318 |
### Example Cache Keys
|
| 319 |
|
api/src/handlers/admin.rs
CHANGED
|
@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
|
|
| 8 |
use crate::cache;
|
| 9 |
use crate::error::AppError;
|
| 10 |
use crate::image::serve::{self, FanartImageKind};
|
| 11 |
-
use crate::services::db::{self, default_ratings_limit, default_logo_backdrop_ratings_limit, default_ratings_order, BadgeDirection, BadgeSize, BadgeStyle, LabelStyle,
|
| 12 |
use crate::AppState;
|
| 13 |
|
| 14 |
#[derive(Serialize)]
|
|
@@ -118,7 +118,7 @@ pub struct GlobalSettingsResponse {
|
|
| 118 |
pub ratings_order: String,
|
| 119 |
pub free_api_key_enabled: bool,
|
| 120 |
pub free_api_key_locked: bool,
|
| 121 |
-
pub poster_position:
|
| 122 |
pub logo_ratings_limit: i32,
|
| 123 |
pub backdrop_ratings_limit: i32,
|
| 124 |
pub poster_badge_style: BadgeStyle,
|
|
@@ -185,7 +185,7 @@ pub struct UpdateGlobalSettingsRequest {
|
|
| 185 |
pub ratings_order: String,
|
| 186 |
pub free_api_key_enabled: Option<bool>,
|
| 187 |
#[serde(default = "db::default_poster_position")]
|
| 188 |
-
pub poster_position:
|
| 189 |
#[serde(default = "default_logo_backdrop_ratings_limit")]
|
| 190 |
pub logo_ratings_limit: i32,
|
| 191 |
#[serde(default = "default_logo_backdrop_ratings_limit")]
|
|
|
|
| 8 |
use crate::cache;
|
| 9 |
use crate::error::AppError;
|
| 10 |
use crate::image::serve::{self, FanartImageKind};
|
| 11 |
+
use crate::services::db::{self, default_ratings_limit, default_logo_backdrop_ratings_limit, default_ratings_order, BadgeDirection, BadgeSize, BadgeStyle, LabelStyle, BadgePosition, PosterSource};
|
| 12 |
use crate::AppState;
|
| 13 |
|
| 14 |
#[derive(Serialize)]
|
|
|
|
| 118 |
pub ratings_order: String,
|
| 119 |
pub free_api_key_enabled: bool,
|
| 120 |
pub free_api_key_locked: bool,
|
| 121 |
+
pub poster_position: BadgePosition,
|
| 122 |
pub logo_ratings_limit: i32,
|
| 123 |
pub backdrop_ratings_limit: i32,
|
| 124 |
pub poster_badge_style: BadgeStyle,
|
|
|
|
| 185 |
pub ratings_order: String,
|
| 186 |
pub free_api_key_enabled: Option<bool>,
|
| 187 |
#[serde(default = "db::default_poster_position")]
|
| 188 |
+
pub poster_position: BadgePosition,
|
| 189 |
#[serde(default = "default_logo_backdrop_ratings_limit")]
|
| 190 |
pub logo_ratings_limit: i32,
|
| 191 |
#[serde(default = "default_logo_backdrop_ratings_limit")]
|
api/src/handlers/api_keys.rs
CHANGED
|
@@ -10,7 +10,7 @@ use sha2::{Digest, Sha256};
|
|
| 10 |
use super::auth::AuthUser;
|
| 11 |
use super::middleware::ApiKeyUser;
|
| 12 |
use crate::error::AppError;
|
| 13 |
-
use crate::services::db::{self, default_ratings_limit, default_logo_backdrop_ratings_limit, default_ratings_order, BadgeDirection, BadgeSize, BadgeStyle, LabelStyle,
|
| 14 |
use crate::services::validation;
|
| 15 |
use crate::AppState;
|
| 16 |
|
|
@@ -100,7 +100,7 @@ pub struct RenderSettingsResponse {
|
|
| 100 |
pub is_default: bool,
|
| 101 |
pub ratings_limit: i32,
|
| 102 |
pub ratings_order: String,
|
| 103 |
-
pub poster_position:
|
| 104 |
pub logo_ratings_limit: i32,
|
| 105 |
pub backdrop_ratings_limit: i32,
|
| 106 |
pub poster_badge_style: BadgeStyle,
|
|
@@ -163,7 +163,7 @@ pub struct UpdateSettingsRequest {
|
|
| 163 |
#[serde(default = "default_ratings_order")]
|
| 164 |
pub ratings_order: String,
|
| 165 |
#[serde(default = "db::default_poster_position")]
|
| 166 |
-
pub poster_position:
|
| 167 |
#[serde(default = "default_logo_backdrop_ratings_limit")]
|
| 168 |
pub logo_ratings_limit: i32,
|
| 169 |
#[serde(default = "default_logo_backdrop_ratings_limit")]
|
|
|
|
| 10 |
use super::auth::AuthUser;
|
| 11 |
use super::middleware::ApiKeyUser;
|
| 12 |
use crate::error::AppError;
|
| 13 |
+
use crate::services::db::{self, default_ratings_limit, default_logo_backdrop_ratings_limit, default_ratings_order, BadgeDirection, BadgeSize, BadgeStyle, LabelStyle, BadgePosition, PosterSource};
|
| 14 |
use crate::services::validation;
|
| 15 |
use crate::AppState;
|
| 16 |
|
|
|
|
| 100 |
pub is_default: bool,
|
| 101 |
pub ratings_limit: i32,
|
| 102 |
pub ratings_order: String,
|
| 103 |
+
pub poster_position: BadgePosition,
|
| 104 |
pub logo_ratings_limit: i32,
|
| 105 |
pub backdrop_ratings_limit: i32,
|
| 106 |
pub poster_badge_style: BadgeStyle,
|
|
|
|
| 163 |
#[serde(default = "default_ratings_order")]
|
| 164 |
pub ratings_order: String,
|
| 165 |
#[serde(default = "db::default_poster_position")]
|
| 166 |
+
pub poster_position: BadgePosition,
|
| 167 |
#[serde(default = "default_logo_backdrop_ratings_limit")]
|
| 168 |
pub logo_ratings_limit: i32,
|
| 169 |
#[serde(default = "default_logo_backdrop_ratings_limit")]
|
api/src/handlers/image.rs
CHANGED
|
@@ -10,7 +10,10 @@ use crate::error::AppError;
|
|
| 10 |
use crate::handlers::auth::hash_api_key;
|
| 11 |
use crate::image::serve;
|
| 12 |
use crate::services::db;
|
| 13 |
-
use crate::services::db::
|
|
|
|
|
|
|
|
|
|
| 14 |
use crate::AppState;
|
| 15 |
|
| 16 |
pub const FREE_API_KEY: &str = "t0-free-rpdb";
|
|
@@ -55,6 +58,57 @@ pub struct ImageQuery {
|
|
| 55 |
#[serde(default, rename = "imageSize")]
|
| 56 |
#[param(rename = "imageSize", default = "medium", value_type = Option<ImageSizeParam>)]
|
| 57 |
pub image_size: Option<String>,
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 58 |
}
|
| 59 |
|
| 60 |
/// Resolve settings for a free API key (global defaults, no per-key DB lookup).
|
|
@@ -166,8 +220,9 @@ pub async fn is_valid_handler(
|
|
| 166 |
}
|
| 167 |
}
|
| 168 |
|
| 169 |
-
/// If `?lang=` was provided, validate it
|
| 170 |
-
|
|
|
|
| 171 |
settings: Arc<db::RenderSettings>,
|
| 172 |
lang: &Option<String>,
|
| 173 |
) -> Result<Arc<db::RenderSettings>, Response> {
|
|
@@ -175,13 +230,84 @@ fn apply_lang_override(
|
|
| 175 |
db::validate_fanart_lang(lang).map_err(|e| e.into_response())?;
|
| 176 |
let mut s = (*settings).clone();
|
| 177 |
s.fanart_lang = Arc::from(lang.as_str());
|
| 178 |
-
s.
|
| 179 |
Ok(Arc::new(s))
|
| 180 |
} else {
|
| 181 |
Ok(settings)
|
| 182 |
}
|
| 183 |
}
|
| 184 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 185 |
/// URL path segment used in CDN redirect URLs for each image type.
|
| 186 |
fn cdn_route_segment(kind: cache::ImageType) -> &'static str {
|
| 187 |
match kind {
|
|
@@ -303,7 +429,11 @@ async fn image_handler_inner(
|
|
| 303 |
Ok(s) => s,
|
| 304 |
Err(resp) => return resp,
|
| 305 |
};
|
| 306 |
-
let settings = match
|
|
|
|
|
|
|
|
|
|
|
|
|
| 307 |
Ok(s) => s,
|
| 308 |
Err(resp) => return resp,
|
| 309 |
};
|
|
@@ -530,4 +660,141 @@ mod tests {
|
|
| 530 |
CDN_ERROR_CACHE_CONTROL,
|
| 531 |
);
|
| 532 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 533 |
}
|
|
|
|
| 10 |
use crate::handlers::auth::hash_api_key;
|
| 11 |
use crate::image::serve;
|
| 12 |
use crate::services::db;
|
| 13 |
+
use crate::services::db::{
|
| 14 |
+
BadgeDirection, BadgeSize, BadgeStyle, LabelStyle, BadgePosition, PosterSource,
|
| 15 |
+
RenderSettings,
|
| 16 |
+
};
|
| 17 |
use crate::AppState;
|
| 18 |
|
| 19 |
pub const FREE_API_KEY: &str = "t0-free-rpdb";
|
|
|
|
| 58 |
#[serde(default, rename = "imageSize")]
|
| 59 |
#[param(rename = "imageSize", default = "medium", value_type = Option<ImageSizeParam>)]
|
| 60 |
pub image_size: Option<String>,
|
| 61 |
+
/// Maximum number of rating badges to display (0–8).
|
| 62 |
+
#[serde(default)]
|
| 63 |
+
#[param(value_type = Option<i32>)]
|
| 64 |
+
pub ratings_limit: Option<i32>,
|
| 65 |
+
/// Comma-separated rating source keys controlling display order (e.g. `imdb,tmdb,rt`).
|
| 66 |
+
#[serde(default)]
|
| 67 |
+
#[param(value_type = Option<String>)]
|
| 68 |
+
pub ratings_order: Option<String>,
|
| 69 |
+
/// Badge layout style: `h` (horizontal), `v` (vertical), `d` (default).
|
| 70 |
+
#[serde(default)]
|
| 71 |
+
#[param(value_type = Option<String>)]
|
| 72 |
+
pub badge_style: Option<BadgeStyle>,
|
| 73 |
+
/// Label rendering style: `t` (text), `i` (icon), `o` (official).
|
| 74 |
+
#[serde(default)]
|
| 75 |
+
#[param(value_type = Option<String>)]
|
| 76 |
+
pub label_style: Option<LabelStyle>,
|
| 77 |
+
/// Badge size: `xs`, `s`, `m`, `l`, `xl`.
|
| 78 |
+
#[serde(default)]
|
| 79 |
+
#[param(value_type = Option<String>)]
|
| 80 |
+
pub badge_size: Option<BadgeSize>,
|
| 81 |
+
/// Badge stacking direction (poster only): `d` (default), `h` (horizontal), `v` (vertical).
|
| 82 |
+
#[serde(default)]
|
| 83 |
+
#[param(value_type = Option<String>)]
|
| 84 |
+
pub badge_direction: Option<BadgeDirection>,
|
| 85 |
+
/// Badge anchor position: `bc`, `tc`, `l`, `r`, `tl`, `tr`, `bl`, `br`.
|
| 86 |
+
#[serde(default)]
|
| 87 |
+
#[param(value_type = Option<String>)]
|
| 88 |
+
pub position: Option<BadgePosition>,
|
| 89 |
+
/// Poster image source (poster only): `t` (TMDB), `f` (Fanart.tv).
|
| 90 |
+
#[serde(default)]
|
| 91 |
+
#[param(value_type = Option<String>)]
|
| 92 |
+
pub poster_source: Option<PosterSource>,
|
| 93 |
+
/// Use textless Fanart.tv posters when available (poster only).
|
| 94 |
+
#[serde(default)]
|
| 95 |
+
#[param(value_type = Option<bool>)]
|
| 96 |
+
pub fanart_textless: Option<bool>,
|
| 97 |
+
}
|
| 98 |
+
|
| 99 |
+
impl ImageQuery {
|
| 100 |
+
/// Returns `true` if any render-setting override query parameter is present.
|
| 101 |
+
fn has_overrides(&self) -> bool {
|
| 102 |
+
self.ratings_limit.is_some()
|
| 103 |
+
|| self.ratings_order.is_some()
|
| 104 |
+
|| self.badge_style.is_some()
|
| 105 |
+
|| self.label_style.is_some()
|
| 106 |
+
|| self.badge_size.is_some()
|
| 107 |
+
|| self.badge_direction.is_some()
|
| 108 |
+
|| self.position.is_some()
|
| 109 |
+
|| self.poster_source.is_some()
|
| 110 |
+
|| self.fanart_textless.is_some()
|
| 111 |
+
}
|
| 112 |
}
|
| 113 |
|
| 114 |
/// Resolve settings for a free API key (global defaults, no per-key DB lookup).
|
|
|
|
| 220 |
}
|
| 221 |
}
|
| 222 |
|
| 223 |
+
/// If `?lang=` was provided, validate it, override `fanart_lang`, and set
|
| 224 |
+
/// `fanart_override` to force the fanart code path.
|
| 225 |
+
fn apply_fanart_override(
|
| 226 |
settings: Arc<db::RenderSettings>,
|
| 227 |
lang: &Option<String>,
|
| 228 |
) -> Result<Arc<db::RenderSettings>, Response> {
|
|
|
|
| 230 |
db::validate_fanart_lang(lang).map_err(|e| e.into_response())?;
|
| 231 |
let mut s = (*settings).clone();
|
| 232 |
s.fanart_lang = Arc::from(lang.as_str());
|
| 233 |
+
s.fanart_override = true;
|
| 234 |
Ok(Arc::new(s))
|
| 235 |
} else {
|
| 236 |
Ok(settings)
|
| 237 |
}
|
| 238 |
}
|
| 239 |
|
| 240 |
+
/// Apply query-parameter overrides to render settings, returning a new `Arc` only
|
| 241 |
+
/// when at least one override is present. Poster-only params are silently ignored
|
| 242 |
+
/// on logo/backdrop endpoints.
|
| 243 |
+
fn apply_query_overrides(
|
| 244 |
+
settings: Arc<db::RenderSettings>,
|
| 245 |
+
query: &ImageQuery,
|
| 246 |
+
kind: cache::ImageType,
|
| 247 |
+
) -> Result<Arc<db::RenderSettings>, Response> {
|
| 248 |
+
if !query.has_overrides() {
|
| 249 |
+
return Ok(settings);
|
| 250 |
+
}
|
| 251 |
+
|
| 252 |
+
let mut s = (*settings).clone();
|
| 253 |
+
|
| 254 |
+
// -- shared overrides (image-type-aware) --
|
| 255 |
+
if let Some(limit) = query.ratings_limit {
|
| 256 |
+
db::validate_ratings_limit(limit).map_err(|e| e.into_response())?;
|
| 257 |
+
match kind {
|
| 258 |
+
cache::ImageType::Poster => s.ratings_limit = limit,
|
| 259 |
+
cache::ImageType::Logo => s.logo_ratings_limit = limit,
|
| 260 |
+
cache::ImageType::Backdrop => s.backdrop_ratings_limit = limit,
|
| 261 |
+
}
|
| 262 |
+
}
|
| 263 |
+
if let Some(ref order) = query.ratings_order {
|
| 264 |
+
db::validate_ratings_order(order).map_err(|e| e.into_response())?;
|
| 265 |
+
s.ratings_order = Arc::from(order.as_str());
|
| 266 |
+
}
|
| 267 |
+
if let Some(style) = query.badge_style {
|
| 268 |
+
match kind {
|
| 269 |
+
cache::ImageType::Poster => s.poster_badge_style = style,
|
| 270 |
+
cache::ImageType::Logo => s.logo_badge_style = style,
|
| 271 |
+
cache::ImageType::Backdrop => s.backdrop_badge_style = style,
|
| 272 |
+
}
|
| 273 |
+
}
|
| 274 |
+
if let Some(style) = query.label_style {
|
| 275 |
+
match kind {
|
| 276 |
+
cache::ImageType::Poster => s.poster_label_style = style,
|
| 277 |
+
cache::ImageType::Logo => s.logo_label_style = style,
|
| 278 |
+
cache::ImageType::Backdrop => s.backdrop_label_style = style,
|
| 279 |
+
}
|
| 280 |
+
}
|
| 281 |
+
if let Some(size) = query.badge_size {
|
| 282 |
+
match kind {
|
| 283 |
+
cache::ImageType::Poster => s.poster_badge_size = size,
|
| 284 |
+
cache::ImageType::Logo => s.logo_badge_size = size,
|
| 285 |
+
cache::ImageType::Backdrop => s.backdrop_badge_size = size,
|
| 286 |
+
}
|
| 287 |
+
}
|
| 288 |
+
|
| 289 |
+
// -- poster-only overrides (silently ignored for logo/backdrop) --
|
| 290 |
+
if kind == cache::ImageType::Poster {
|
| 291 |
+
if let Some(dir) = query.badge_direction {
|
| 292 |
+
s.poster_badge_direction = dir;
|
| 293 |
+
}
|
| 294 |
+
if let Some(pos) = query.position {
|
| 295 |
+
s.poster_position = pos;
|
| 296 |
+
}
|
| 297 |
+
if let Some(src) = query.poster_source {
|
| 298 |
+
s.poster_source = src;
|
| 299 |
+
}
|
| 300 |
+
if let Some(textless) = query.fanart_textless {
|
| 301 |
+
s.fanart_textless = textless;
|
| 302 |
+
if textless {
|
| 303 |
+
s.fanart_override = true;
|
| 304 |
+
}
|
| 305 |
+
}
|
| 306 |
+
}
|
| 307 |
+
|
| 308 |
+
Ok(Arc::new(s))
|
| 309 |
+
}
|
| 310 |
+
|
| 311 |
/// URL path segment used in CDN redirect URLs for each image type.
|
| 312 |
fn cdn_route_segment(kind: cache::ImageType) -> &'static str {
|
| 313 |
match kind {
|
|
|
|
| 429 |
Ok(s) => s,
|
| 430 |
Err(resp) => return resp,
|
| 431 |
};
|
| 432 |
+
let settings = match apply_fanart_override(settings, &query.lang) {
|
| 433 |
+
Ok(s) => s,
|
| 434 |
+
Err(resp) => return resp,
|
| 435 |
+
};
|
| 436 |
+
let settings = match apply_query_overrides(settings, &query, kind) {
|
| 437 |
Ok(s) => s,
|
| 438 |
Err(resp) => return resp,
|
| 439 |
};
|
|
|
|
| 660 |
CDN_ERROR_CACHE_CONTROL,
|
| 661 |
);
|
| 662 |
}
|
| 663 |
+
|
| 664 |
+
fn empty_query() -> ImageQuery {
|
| 665 |
+
ImageQuery {
|
| 666 |
+
fallback: None,
|
| 667 |
+
lang: None,
|
| 668 |
+
image_size: None,
|
| 669 |
+
ratings_limit: None,
|
| 670 |
+
ratings_order: None,
|
| 671 |
+
badge_style: None,
|
| 672 |
+
label_style: None,
|
| 673 |
+
badge_size: None,
|
| 674 |
+
badge_direction: None,
|
| 675 |
+
position: None,
|
| 676 |
+
poster_source: None,
|
| 677 |
+
fanart_textless: None,
|
| 678 |
+
}
|
| 679 |
+
}
|
| 680 |
+
|
| 681 |
+
#[test]
|
| 682 |
+
fn apply_query_overrides_no_overrides_returns_same_arc() {
|
| 683 |
+
let settings = Arc::new(db::RenderSettings::default());
|
| 684 |
+
let query = empty_query();
|
| 685 |
+
let result =
|
| 686 |
+
apply_query_overrides(settings.clone(), &query, cache::ImageType::Poster).unwrap();
|
| 687 |
+
assert!(Arc::ptr_eq(&settings, &result));
|
| 688 |
+
}
|
| 689 |
+
|
| 690 |
+
#[test]
|
| 691 |
+
fn apply_query_overrides_poster_maps_correctly() {
|
| 692 |
+
let settings = Arc::new(db::RenderSettings::default());
|
| 693 |
+
let query = ImageQuery {
|
| 694 |
+
ratings_limit: Some(3),
|
| 695 |
+
badge_style: Some(BadgeStyle::Horizontal),
|
| 696 |
+
label_style: Some(LabelStyle::Icon),
|
| 697 |
+
badge_size: Some(BadgeSize::Large),
|
| 698 |
+
badge_direction: Some(BadgeDirection::Horizontal),
|
| 699 |
+
position: Some(BadgePosition::TopLeft),
|
| 700 |
+
poster_source: Some(PosterSource::Fanart),
|
| 701 |
+
fanart_textless: Some(true),
|
| 702 |
+
ratings_order: Some("imdb,tmdb".into()),
|
| 703 |
+
..empty_query()
|
| 704 |
+
};
|
| 705 |
+
let result =
|
| 706 |
+
apply_query_overrides(settings, &query, cache::ImageType::Poster).unwrap();
|
| 707 |
+
assert_eq!(result.ratings_limit, 3);
|
| 708 |
+
assert_eq!(result.poster_badge_style, BadgeStyle::Horizontal);
|
| 709 |
+
assert_eq!(result.poster_label_style, LabelStyle::Icon);
|
| 710 |
+
assert_eq!(result.poster_badge_size, BadgeSize::Large);
|
| 711 |
+
assert_eq!(result.poster_badge_direction, BadgeDirection::Horizontal);
|
| 712 |
+
assert_eq!(result.poster_position, BadgePosition::TopLeft);
|
| 713 |
+
assert_eq!(result.poster_source, PosterSource::Fanart);
|
| 714 |
+
assert!(result.fanart_textless);
|
| 715 |
+
assert!(result.fanart_override, "fanart_textless=true should set fanart_override to trigger fanart path");
|
| 716 |
+
assert_eq!(&*result.ratings_order, "imdb,tmdb");
|
| 717 |
+
}
|
| 718 |
+
|
| 719 |
+
#[test]
|
| 720 |
+
fn apply_query_overrides_logo_maps_correctly_ignores_poster_only() {
|
| 721 |
+
let settings = Arc::new(db::RenderSettings::default());
|
| 722 |
+
let original_position = settings.poster_position;
|
| 723 |
+
let original_direction = settings.poster_badge_direction;
|
| 724 |
+
let original_source = settings.poster_source;
|
| 725 |
+
let original_textless = settings.fanart_textless;
|
| 726 |
+
|
| 727 |
+
let query = ImageQuery {
|
| 728 |
+
ratings_limit: Some(2),
|
| 729 |
+
badge_style: Some(BadgeStyle::Vertical),
|
| 730 |
+
label_style: Some(LabelStyle::Text),
|
| 731 |
+
badge_size: Some(BadgeSize::Small),
|
| 732 |
+
badge_direction: Some(BadgeDirection::Horizontal),
|
| 733 |
+
position: Some(BadgePosition::TopRight),
|
| 734 |
+
poster_source: Some(PosterSource::Fanart),
|
| 735 |
+
fanart_textless: Some(true),
|
| 736 |
+
..empty_query()
|
| 737 |
+
};
|
| 738 |
+
let result =
|
| 739 |
+
apply_query_overrides(settings, &query, cache::ImageType::Logo).unwrap();
|
| 740 |
+
// Logo-specific fields applied
|
| 741 |
+
assert_eq!(result.logo_ratings_limit, 2);
|
| 742 |
+
assert_eq!(result.logo_badge_style, BadgeStyle::Vertical);
|
| 743 |
+
assert_eq!(result.logo_label_style, LabelStyle::Text);
|
| 744 |
+
assert_eq!(result.logo_badge_size, BadgeSize::Small);
|
| 745 |
+
// Poster-only fields unchanged
|
| 746 |
+
assert_eq!(result.poster_position, original_position);
|
| 747 |
+
assert_eq!(result.poster_badge_direction, original_direction);
|
| 748 |
+
assert_eq!(result.poster_source, original_source);
|
| 749 |
+
assert_eq!(result.fanart_textless, original_textless);
|
| 750 |
+
}
|
| 751 |
+
|
| 752 |
+
#[test]
|
| 753 |
+
fn apply_query_overrides_backdrop_maps_correctly() {
|
| 754 |
+
let settings = Arc::new(db::RenderSettings::default());
|
| 755 |
+
let query = ImageQuery {
|
| 756 |
+
ratings_limit: Some(5),
|
| 757 |
+
badge_style: Some(BadgeStyle::Default),
|
| 758 |
+
..empty_query()
|
| 759 |
+
};
|
| 760 |
+
let result =
|
| 761 |
+
apply_query_overrides(settings, &query, cache::ImageType::Backdrop).unwrap();
|
| 762 |
+
assert_eq!(result.backdrop_ratings_limit, 5);
|
| 763 |
+
assert_eq!(result.backdrop_badge_style, BadgeStyle::Default);
|
| 764 |
+
}
|
| 765 |
+
|
| 766 |
+
#[test]
|
| 767 |
+
fn apply_query_overrides_rejects_invalid_ratings_limit() {
|
| 768 |
+
let settings = Arc::new(db::RenderSettings::default());
|
| 769 |
+
let query = ImageQuery {
|
| 770 |
+
ratings_limit: Some(9),
|
| 771 |
+
..empty_query()
|
| 772 |
+
};
|
| 773 |
+
let result = apply_query_overrides(settings, &query, cache::ImageType::Poster);
|
| 774 |
+
assert!(result.is_err());
|
| 775 |
+
}
|
| 776 |
+
|
| 777 |
+
#[test]
|
| 778 |
+
fn apply_query_overrides_rejects_invalid_ratings_order() {
|
| 779 |
+
let settings = Arc::new(db::RenderSettings::default());
|
| 780 |
+
let query = ImageQuery {
|
| 781 |
+
ratings_order: Some("bogus_source".into()),
|
| 782 |
+
..empty_query()
|
| 783 |
+
};
|
| 784 |
+
let result = apply_query_overrides(settings, &query, cache::ImageType::Poster);
|
| 785 |
+
assert!(result.is_err());
|
| 786 |
+
}
|
| 787 |
+
|
| 788 |
+
#[test]
|
| 789 |
+
fn apply_query_overrides_fanart_textless_false_does_not_set_fanart_override() {
|
| 790 |
+
let settings = Arc::new(db::RenderSettings::default());
|
| 791 |
+
let query = ImageQuery {
|
| 792 |
+
fanart_textless: Some(false),
|
| 793 |
+
..empty_query()
|
| 794 |
+
};
|
| 795 |
+
let result =
|
| 796 |
+
apply_query_overrides(settings, &query, cache::ImageType::Poster).unwrap();
|
| 797 |
+
assert!(!result.fanart_textless);
|
| 798 |
+
assert!(!result.fanart_override);
|
| 799 |
+
}
|
| 800 |
}
|
api/src/handlers/preview.rs
CHANGED
|
@@ -3,14 +3,16 @@ use axum::http::header;
|
|
| 3 |
use axum::response::{IntoResponse, Response};
|
| 4 |
use image::codecs::png::PngEncoder;
|
| 5 |
use image::{ImageEncoder, Rgba, RgbaImage};
|
| 6 |
-
use serde::Deserialize;
|
| 7 |
use std::sync::{Arc, LazyLock};
|
| 8 |
|
| 9 |
use crate::cache;
|
| 10 |
use crate::error::AppError;
|
|
|
|
| 11 |
use crate::image::generate;
|
| 12 |
use crate::image::serve;
|
| 13 |
-
use crate::services::db::{self, BadgeDirection,
|
|
|
|
|
|
|
| 14 |
use crate::services::ratings::{self, RatingBadge, RatingSource};
|
| 15 |
use crate::AppState;
|
| 16 |
|
|
@@ -85,24 +87,49 @@ fn sample_badges() -> Vec<RatingBadge> {
|
|
| 85 |
]
|
| 86 |
}
|
| 87 |
|
| 88 |
-
|
| 89 |
-
|
| 90 |
-
|
| 91 |
-
|
| 92 |
-
|
| 93 |
-
|
| 94 |
-
|
| 95 |
-
|
| 96 |
-
|
| 97 |
-
|
| 98 |
-
|
| 99 |
-
|
| 100 |
-
|
| 101 |
-
|
| 102 |
-
|
| 103 |
-
|
| 104 |
-
|
| 105 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 106 |
}
|
| 107 |
|
| 108 |
/// Parse and validate the optional `imageSize` query parameter for previews.
|
|
@@ -116,34 +143,31 @@ fn parse_preview_image_size(
|
|
| 116 |
}
|
| 117 |
}
|
| 118 |
|
| 119 |
-
fn default_ratings_limit() -> i32 {
|
| 120 |
-
3
|
| 121 |
-
}
|
| 122 |
-
|
| 123 |
pub async fn preview_poster(
|
| 124 |
State(state): State<Arc<AppState>>,
|
| 125 |
-
Query(query): Query<
|
| 126 |
) -> Result<Response, AppError> {
|
| 127 |
let image_size = parse_preview_image_size(&query.image_size, cache::ImageType::Poster)?;
|
| 128 |
-
let badge_size = query.badge_size;
|
| 129 |
let resolved_size = serve::resolve_image_size(image_size);
|
| 130 |
let target_width = resolved_size.poster_target_width();
|
| 131 |
let badge_scale = resolved_size.badge_scale(cache::ImageType::Poster) * badge_size.scale_factor();
|
| 132 |
|
| 133 |
-
let
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 134 |
let raw_badge_style = query.badge_style.unwrap_or(BadgeStyle::Default);
|
| 135 |
-
let label_style = query.label_style;
|
| 136 |
-
let badge_direction = query.badge_direction.resolve(position);
|
| 137 |
let badge_style = raw_badge_style.resolve(badge_direction);
|
| 138 |
-
let
|
| 139 |
-
let
|
| 140 |
-
let
|
| 141 |
-
let
|
| 142 |
-
let
|
| 143 |
-
let bsz_suffix = badge_size.cache_suffix();
|
| 144 |
-
let is_suffix = serve::image_size_cache_suffix(image_size);
|
| 145 |
-
let cache_key = format!("preview:{suffix}{pos_suffix}{bs_suffix}{ls_suffix}{bd_suffix}{bsz_suffix}{is_suffix}");
|
| 146 |
-
let cache_path = cache::preview_path(&state.config.cache_dir, cache::ImageType::Poster, &format!("{suffix}{pos_suffix}{bs_suffix}{ls_suffix}{bd_suffix}{bsz_suffix}{is_suffix}"), "jpg")?;
|
| 147 |
|
| 148 |
// 1. Check in-memory cache
|
| 149 |
if let Some(cached) = state.preview_cache.get(&cache_key).await {
|
|
@@ -159,7 +183,7 @@ pub async fn preview_poster(
|
|
| 159 |
|
| 160 |
// 3. Render and cache to both layers
|
| 161 |
let badges = sample_badges();
|
| 162 |
-
let badges = ratings::apply_rating_preferences(badges,
|
| 163 |
|
| 164 |
let poster_png: &'static Vec<u8> = &SAMPLE_POSTER_PNG;
|
| 165 |
let font = state.font.clone();
|
|
@@ -179,23 +203,26 @@ pub async fn preview_poster(
|
|
| 179 |
|
| 180 |
pub async fn preview_logo(
|
| 181 |
State(state): State<Arc<AppState>>,
|
| 182 |
-
Query(query): Query<
|
| 183 |
) -> Result<Response, AppError> {
|
| 184 |
let image_size = parse_preview_image_size(&query.image_size, cache::ImageType::Logo)?;
|
| 185 |
-
let badge_size = query.badge_size;
|
| 186 |
let resolved_size = serve::resolve_image_size(image_size);
|
| 187 |
let target_width = resolved_size.logo_target_width();
|
| 188 |
let badge_scale = resolved_size.badge_scale(cache::ImageType::Logo) * badge_size.scale_factor();
|
| 189 |
|
| 190 |
-
let
|
| 191 |
-
|
| 192 |
-
let
|
| 193 |
-
let
|
| 194 |
-
|
| 195 |
-
let
|
| 196 |
-
let
|
| 197 |
-
let
|
| 198 |
-
let
|
|
|
|
|
|
|
|
|
|
| 199 |
|
| 200 |
if let Some(cached) = state.preview_cache.get(&cache_key).await {
|
| 201 |
return Ok(preview_png_response(cached));
|
|
@@ -208,7 +235,7 @@ pub async fn preview_logo(
|
|
| 208 |
}
|
| 209 |
|
| 210 |
let badges = sample_badges();
|
| 211 |
-
let badges = ratings::apply_rating_preferences(badges,
|
| 212 |
|
| 213 |
let logo_png: &'static Vec<u8> = &SAMPLE_LOGO_PNG;
|
| 214 |
let font = state.font.clone();
|
|
@@ -228,23 +255,26 @@ pub async fn preview_logo(
|
|
| 228 |
|
| 229 |
pub async fn preview_backdrop(
|
| 230 |
State(state): State<Arc<AppState>>,
|
| 231 |
-
Query(query): Query<
|
| 232 |
) -> Result<Response, AppError> {
|
| 233 |
let image_size = parse_preview_image_size(&query.image_size, cache::ImageType::Backdrop)?;
|
| 234 |
-
let badge_size = query.badge_size;
|
| 235 |
let resolved_size = serve::resolve_image_size(image_size);
|
| 236 |
let target_width = resolved_size.backdrop_target_width();
|
| 237 |
let badge_scale = resolved_size.badge_scale(cache::ImageType::Backdrop) * badge_size.scale_factor();
|
| 238 |
|
| 239 |
-
let
|
| 240 |
-
|
| 241 |
-
let
|
| 242 |
-
let
|
| 243 |
-
|
| 244 |
-
let
|
| 245 |
-
let
|
| 246 |
-
let
|
| 247 |
-
let
|
|
|
|
|
|
|
|
|
|
| 248 |
|
| 249 |
if let Some(cached) = state.preview_cache.get(&cache_key).await {
|
| 250 |
return Ok(preview_response(cached));
|
|
@@ -257,7 +287,7 @@ pub async fn preview_backdrop(
|
|
| 257 |
}
|
| 258 |
|
| 259 |
let badges = sample_badges();
|
| 260 |
-
let badges = ratings::apply_rating_preferences(badges,
|
| 261 |
|
| 262 |
let backdrop_png: &'static Vec<u8> = &SAMPLE_BACKDROP_PNG;
|
| 263 |
let font = state.font.clone();
|
|
@@ -334,7 +364,7 @@ mod tests {
|
|
| 334 |
fn sample_poster_renders_with_badges() {
|
| 335 |
let font = ab_glyph::FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 336 |
let badges = sample_badges();
|
| 337 |
-
let result = generate::render_poster_sync(&SAMPLE_POSTER_PNG, &badges, &font, 85,
|
| 338 |
let buf = result.expect("rendering should succeed");
|
| 339 |
// Valid JPEG
|
| 340 |
assert_eq!(buf[0], 0xFF);
|
|
@@ -345,34 +375,35 @@ mod tests {
|
|
| 345 |
#[test]
|
| 346 |
fn sample_poster_renders_with_no_badges() {
|
| 347 |
let font = ab_glyph::FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 348 |
-
let result = generate::render_poster_sync(&SAMPLE_POSTER_PNG, &[], &font, 85,
|
| 349 |
let buf = result.expect("rendering should succeed");
|
| 350 |
assert_eq!(buf[0], 0xFF);
|
| 351 |
assert_eq!(buf[1], 0xD8);
|
| 352 |
}
|
| 353 |
|
| 354 |
#[test]
|
| 355 |
-
fn
|
| 356 |
-
assert_eq!(default_ratings_limit()
|
|
|
|
| 357 |
}
|
| 358 |
|
| 359 |
#[test]
|
| 360 |
-
fn
|
| 361 |
// Simulate what axum does with no query params — serde defaults apply
|
| 362 |
-
let query:
|
| 363 |
-
assert_eq!(query.ratings_limit,
|
| 364 |
-
assert_eq!(query.ratings_order,
|
| 365 |
assert_eq!(query.badge_style, None);
|
| 366 |
-
assert_eq!(query.label_style,
|
| 367 |
-
assert_eq!(query.badge_direction,
|
| 368 |
assert!(query.image_size.is_none());
|
| 369 |
}
|
| 370 |
|
| 371 |
#[test]
|
| 372 |
-
fn
|
| 373 |
-
let query:
|
| 374 |
serde_json::from_str(r#"{"ratings_limit":5,"ratings_order":"imdb,rt"}"#).unwrap();
|
| 375 |
-
assert_eq!(query.ratings_limit, 5);
|
| 376 |
-
assert_eq!(query.ratings_order, "imdb,rt");
|
| 377 |
}
|
| 378 |
}
|
|
|
|
| 3 |
use axum::response::{IntoResponse, Response};
|
| 4 |
use image::codecs::png::PngEncoder;
|
| 5 |
use image::{ImageEncoder, Rgba, RgbaImage};
|
|
|
|
| 6 |
use std::sync::{Arc, LazyLock};
|
| 7 |
|
| 8 |
use crate::cache;
|
| 9 |
use crate::error::AppError;
|
| 10 |
+
use crate::handlers::image::ImageQuery;
|
| 11 |
use crate::image::generate;
|
| 12 |
use crate::image::serve;
|
| 13 |
+
use crate::services::db::{self, BadgeDirection, BadgeStyle, BadgePosition, RenderSettings};
|
| 14 |
+
#[cfg(test)]
|
| 15 |
+
use crate::services::db::{BadgeSize, LabelStyle};
|
| 16 |
use crate::services::ratings::{self, RatingBadge, RatingSource};
|
| 17 |
use crate::AppState;
|
| 18 |
|
|
|
|
| 87 |
]
|
| 88 |
}
|
| 89 |
|
| 90 |
+
const PREVIEW_POSTER_RATINGS_LIMIT: i32 = 3;
|
| 91 |
+
const PREVIEW_LOGO_BACKDROP_RATINGS_LIMIT: i32 = 5;
|
| 92 |
+
|
| 93 |
+
/// Build a `RenderSettings` populated with the given preview parameters for
|
| 94 |
+
/// the specified image kind. Only the fields relevant to `kind` are set;
|
| 95 |
+
/// the rest use defaults. This allows preview handlers to delegate cache key
|
| 96 |
+
/// construction to `serve::settings_cache_suffix_with_ratings`, keeping cache
|
| 97 |
+
/// key format in sync with the main image-serving path.
|
| 98 |
+
fn preview_render_settings(
|
| 99 |
+
kind: cache::ImageType,
|
| 100 |
+
badge_style: BadgeStyle,
|
| 101 |
+
label_style: db::LabelStyle,
|
| 102 |
+
badge_size: db::BadgeSize,
|
| 103 |
+
position: BadgePosition,
|
| 104 |
+
badge_direction: BadgeDirection,
|
| 105 |
+
ratings_limit: i32,
|
| 106 |
+
ratings_order: &str,
|
| 107 |
+
) -> RenderSettings {
|
| 108 |
+
let mut s = RenderSettings::default();
|
| 109 |
+
s.ratings_order = std::sync::Arc::from(ratings_order);
|
| 110 |
+
match kind {
|
| 111 |
+
cache::ImageType::Poster => {
|
| 112 |
+
s.ratings_limit = ratings_limit;
|
| 113 |
+
s.poster_badge_style = badge_style;
|
| 114 |
+
s.poster_label_style = label_style;
|
| 115 |
+
s.poster_badge_size = badge_size;
|
| 116 |
+
s.poster_position = position;
|
| 117 |
+
s.poster_badge_direction = badge_direction;
|
| 118 |
+
}
|
| 119 |
+
cache::ImageType::Logo => {
|
| 120 |
+
s.logo_ratings_limit = ratings_limit;
|
| 121 |
+
s.logo_badge_style = badge_style;
|
| 122 |
+
s.logo_label_style = label_style;
|
| 123 |
+
s.logo_badge_size = badge_size;
|
| 124 |
+
}
|
| 125 |
+
cache::ImageType::Backdrop => {
|
| 126 |
+
s.backdrop_ratings_limit = ratings_limit;
|
| 127 |
+
s.backdrop_badge_style = badge_style;
|
| 128 |
+
s.backdrop_label_style = label_style;
|
| 129 |
+
s.backdrop_badge_size = badge_size;
|
| 130 |
+
}
|
| 131 |
+
}
|
| 132 |
+
s
|
| 133 |
}
|
| 134 |
|
| 135 |
/// Parse and validate the optional `imageSize` query parameter for previews.
|
|
|
|
| 143 |
}
|
| 144 |
}
|
| 145 |
|
|
|
|
|
|
|
|
|
|
|
|
|
| 146 |
pub async fn preview_poster(
|
| 147 |
State(state): State<Arc<AppState>>,
|
| 148 |
+
Query(query): Query<ImageQuery>,
|
| 149 |
) -> Result<Response, AppError> {
|
| 150 |
let image_size = parse_preview_image_size(&query.image_size, cache::ImageType::Poster)?;
|
| 151 |
+
let badge_size = query.badge_size.unwrap_or(db::default_badge_size());
|
| 152 |
let resolved_size = serve::resolve_image_size(image_size);
|
| 153 |
let target_width = resolved_size.poster_target_width();
|
| 154 |
let badge_scale = resolved_size.badge_scale(cache::ImageType::Poster) * badge_size.scale_factor();
|
| 155 |
|
| 156 |
+
let ratings_limit = query.ratings_limit.unwrap_or(PREVIEW_POSTER_RATINGS_LIMIT);
|
| 157 |
+
db::validate_ratings_limit(ratings_limit)?;
|
| 158 |
+
let default_order = db::default_ratings_order();
|
| 159 |
+
let ratings_order = query.ratings_order.as_deref().unwrap_or(&default_order);
|
| 160 |
+
db::validate_ratings_order(ratings_order)?;
|
| 161 |
+
let position = query.position.unwrap_or(BadgePosition::BottomCenter);
|
| 162 |
let raw_badge_style = query.badge_style.unwrap_or(BadgeStyle::Default);
|
| 163 |
+
let label_style = query.label_style.unwrap_or(db::default_label_style());
|
| 164 |
+
let badge_direction = query.badge_direction.unwrap_or(db::default_poster_badge_direction()).resolve(position);
|
| 165 |
let badge_style = raw_badge_style.resolve(badge_direction);
|
| 166 |
+
let ratings_suffix = ratings::ratings_cache_suffix(ratings_order, ratings_limit);
|
| 167 |
+
let preview_settings = preview_render_settings(cache::ImageType::Poster, badge_style, label_style, badge_size, position, badge_direction, ratings_limit, ratings_order);
|
| 168 |
+
let suffix = serve::settings_cache_suffix_with_ratings(&preview_settings, cache::ImageType::Poster, image_size, &ratings_suffix);
|
| 169 |
+
let cache_key = format!("preview:{suffix}");
|
| 170 |
+
let cache_path = cache::preview_path(&state.config.cache_dir, cache::ImageType::Poster, &suffix, "jpg")?;
|
|
|
|
|
|
|
|
|
|
|
|
|
| 171 |
|
| 172 |
// 1. Check in-memory cache
|
| 173 |
if let Some(cached) = state.preview_cache.get(&cache_key).await {
|
|
|
|
| 183 |
|
| 184 |
// 3. Render and cache to both layers
|
| 185 |
let badges = sample_badges();
|
| 186 |
+
let badges = ratings::apply_rating_preferences(badges, ratings_order, ratings_limit);
|
| 187 |
|
| 188 |
let poster_png: &'static Vec<u8> = &SAMPLE_POSTER_PNG;
|
| 189 |
let font = state.font.clone();
|
|
|
|
| 203 |
|
| 204 |
pub async fn preview_logo(
|
| 205 |
State(state): State<Arc<AppState>>,
|
| 206 |
+
Query(query): Query<ImageQuery>,
|
| 207 |
) -> Result<Response, AppError> {
|
| 208 |
let image_size = parse_preview_image_size(&query.image_size, cache::ImageType::Logo)?;
|
| 209 |
+
let badge_size = query.badge_size.unwrap_or(db::default_badge_size());
|
| 210 |
let resolved_size = serve::resolve_image_size(image_size);
|
| 211 |
let target_width = resolved_size.logo_target_width();
|
| 212 |
let badge_scale = resolved_size.badge_scale(cache::ImageType::Logo) * badge_size.scale_factor();
|
| 213 |
|
| 214 |
+
let ratings_limit = query.ratings_limit.unwrap_or(PREVIEW_LOGO_BACKDROP_RATINGS_LIMIT);
|
| 215 |
+
db::validate_ratings_limit(ratings_limit)?;
|
| 216 |
+
let default_order = db::default_ratings_order();
|
| 217 |
+
let ratings_order = query.ratings_order.as_deref().unwrap_or(&default_order);
|
| 218 |
+
db::validate_ratings_order(ratings_order)?;
|
| 219 |
+
let badge_style = query.badge_style.unwrap_or(BadgeStyle::Horizontal).resolve(BadgeDirection::Vertical);
|
| 220 |
+
let label_style = query.label_style.unwrap_or(db::default_label_style());
|
| 221 |
+
let ratings_suffix = ratings::ratings_cache_suffix(ratings_order, ratings_limit);
|
| 222 |
+
let preview_settings = preview_render_settings(cache::ImageType::Logo, badge_style, label_style, badge_size, BadgePosition::BottomCenter, BadgeDirection::Horizontal, ratings_limit, ratings_order);
|
| 223 |
+
let suffix = serve::settings_cache_suffix_with_ratings(&preview_settings, cache::ImageType::Logo, image_size, &ratings_suffix);
|
| 224 |
+
let cache_key = format!("preview-logo:{suffix}");
|
| 225 |
+
let cache_path = cache::preview_path(&state.config.cache_dir, cache::ImageType::Logo, &suffix, "png")?;
|
| 226 |
|
| 227 |
if let Some(cached) = state.preview_cache.get(&cache_key).await {
|
| 228 |
return Ok(preview_png_response(cached));
|
|
|
|
| 235 |
}
|
| 236 |
|
| 237 |
let badges = sample_badges();
|
| 238 |
+
let badges = ratings::apply_rating_preferences(badges, ratings_order, ratings_limit);
|
| 239 |
|
| 240 |
let logo_png: &'static Vec<u8> = &SAMPLE_LOGO_PNG;
|
| 241 |
let font = state.font.clone();
|
|
|
|
| 255 |
|
| 256 |
pub async fn preview_backdrop(
|
| 257 |
State(state): State<Arc<AppState>>,
|
| 258 |
+
Query(query): Query<ImageQuery>,
|
| 259 |
) -> Result<Response, AppError> {
|
| 260 |
let image_size = parse_preview_image_size(&query.image_size, cache::ImageType::Backdrop)?;
|
| 261 |
+
let badge_size = query.badge_size.unwrap_or(db::default_badge_size());
|
| 262 |
let resolved_size = serve::resolve_image_size(image_size);
|
| 263 |
let target_width = resolved_size.backdrop_target_width();
|
| 264 |
let badge_scale = resolved_size.badge_scale(cache::ImageType::Backdrop) * badge_size.scale_factor();
|
| 265 |
|
| 266 |
+
let ratings_limit = query.ratings_limit.unwrap_or(PREVIEW_LOGO_BACKDROP_RATINGS_LIMIT);
|
| 267 |
+
db::validate_ratings_limit(ratings_limit)?;
|
| 268 |
+
let default_order = db::default_ratings_order();
|
| 269 |
+
let ratings_order = query.ratings_order.as_deref().unwrap_or(&default_order);
|
| 270 |
+
db::validate_ratings_order(ratings_order)?;
|
| 271 |
+
let badge_style = query.badge_style.unwrap_or(BadgeStyle::Vertical).resolve(BadgeDirection::Vertical);
|
| 272 |
+
let label_style = query.label_style.unwrap_or(db::default_label_style());
|
| 273 |
+
let ratings_suffix = ratings::ratings_cache_suffix(ratings_order, ratings_limit);
|
| 274 |
+
let preview_settings = preview_render_settings(cache::ImageType::Backdrop, badge_style, label_style, badge_size, BadgePosition::BottomCenter, BadgeDirection::Horizontal, ratings_limit, ratings_order);
|
| 275 |
+
let suffix = serve::settings_cache_suffix_with_ratings(&preview_settings, cache::ImageType::Backdrop, image_size, &ratings_suffix);
|
| 276 |
+
let cache_key = format!("preview-backdrop:{suffix}");
|
| 277 |
+
let cache_path = cache::preview_path(&state.config.cache_dir, cache::ImageType::Backdrop, &suffix, "jpg")?;
|
| 278 |
|
| 279 |
if let Some(cached) = state.preview_cache.get(&cache_key).await {
|
| 280 |
return Ok(preview_response(cached));
|
|
|
|
| 287 |
}
|
| 288 |
|
| 289 |
let badges = sample_badges();
|
| 290 |
+
let badges = ratings::apply_rating_preferences(badges, ratings_order, ratings_limit);
|
| 291 |
|
| 292 |
let backdrop_png: &'static Vec<u8> = &SAMPLE_BACKDROP_PNG;
|
| 293 |
let font = state.font.clone();
|
|
|
|
| 364 |
fn sample_poster_renders_with_badges() {
|
| 365 |
let font = ab_glyph::FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 366 |
let badges = sample_badges();
|
| 367 |
+
let result = generate::render_poster_sync(&SAMPLE_POSTER_PNG, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium);
|
| 368 |
let buf = result.expect("rendering should succeed");
|
| 369 |
// Valid JPEG
|
| 370 |
assert_eq!(buf[0], 0xFF);
|
|
|
|
| 375 |
#[test]
|
| 376 |
fn sample_poster_renders_with_no_badges() {
|
| 377 |
let font = ab_glyph::FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 378 |
+
let result = generate::render_poster_sync(&SAMPLE_POSTER_PNG, &[], &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium);
|
| 379 |
let buf = result.expect("rendering should succeed");
|
| 380 |
assert_eq!(buf[0], 0xFF);
|
| 381 |
assert_eq!(buf[1], 0xD8);
|
| 382 |
}
|
| 383 |
|
| 384 |
#[test]
|
| 385 |
+
fn preview_default_ratings_limits_match_handler_defaults() {
|
| 386 |
+
assert_eq!(PREVIEW_POSTER_RATINGS_LIMIT, db::default_ratings_limit());
|
| 387 |
+
assert_eq!(PREVIEW_LOGO_BACKDROP_RATINGS_LIMIT, db::default_logo_backdrop_ratings_limit());
|
| 388 |
}
|
| 389 |
|
| 390 |
#[test]
|
| 391 |
+
fn image_query_defaults() {
|
| 392 |
// Simulate what axum does with no query params — serde defaults apply
|
| 393 |
+
let query: ImageQuery = serde_json::from_str("{}").unwrap();
|
| 394 |
+
assert_eq!(query.ratings_limit, None);
|
| 395 |
+
assert_eq!(query.ratings_order, None);
|
| 396 |
assert_eq!(query.badge_style, None);
|
| 397 |
+
assert_eq!(query.label_style, None);
|
| 398 |
+
assert_eq!(query.badge_direction, None);
|
| 399 |
assert!(query.image_size.is_none());
|
| 400 |
}
|
| 401 |
|
| 402 |
#[test]
|
| 403 |
+
fn image_query_custom_values() {
|
| 404 |
+
let query: ImageQuery =
|
| 405 |
serde_json::from_str(r#"{"ratings_limit":5,"ratings_order":"imdb,rt"}"#).unwrap();
|
| 406 |
+
assert_eq!(query.ratings_limit, Some(5));
|
| 407 |
+
assert_eq!(query.ratings_order.as_deref(), Some("imdb,rt"));
|
| 408 |
}
|
| 409 |
}
|
api/src/image/generate.rs
CHANGED
|
@@ -8,7 +8,7 @@ use tokio::sync::Semaphore;
|
|
| 8 |
use crate::cache;
|
| 9 |
use crate::error::AppError;
|
| 10 |
use crate::image::badge;
|
| 11 |
-
use crate::services::db::{BadgeDirection, BadgeSize, BadgeStyle, LabelStyle,
|
| 12 |
use crate::services::ratings::RatingBadge;
|
| 13 |
use crate::services::tmdb::TmdbClient;
|
| 14 |
|
|
@@ -34,7 +34,7 @@ pub struct ImageParams<'a> {
|
|
| 34 |
pub cache_dir: &'a str,
|
| 35 |
pub image_stale_secs: u64,
|
| 36 |
pub poster_bytes_override: Option<Vec<u8>>,
|
| 37 |
-
pub poster_position:
|
| 38 |
pub badge_style: BadgeStyle,
|
| 39 |
pub label_style: LabelStyle,
|
| 40 |
pub badge_direction: BadgeDirection,
|
|
@@ -141,7 +141,7 @@ pub async fn generate_poster(params: ImageParams<'_>) -> Result<Vec<u8>, AppErro
|
|
| 141 |
}
|
| 142 |
|
| 143 |
/// Overlay badges in a vertical column, positioned according to `poster_position`.
|
| 144 |
-
fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], poster_position:
|
| 145 |
let vert_spacing = (BADGE_VERT_SPACING as f32 * badge_scale).round() as u32;
|
| 146 |
let top_margin = (BADGE_TOP_MARGIN as f32 * badge_scale).round() as u32;
|
| 147 |
let bottom_margin = (BADGE_BOTTOM_MARGIN as f32 * badge_scale).round() as u32;
|
|
@@ -189,7 +189,7 @@ fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], po
|
|
| 189 |
}
|
| 190 |
|
| 191 |
/// Overlay badges in horizontal rows, positioned according to `poster_position`.
|
| 192 |
-
fn overlay_horizontal_rows(canvas: &mut RgbaImage, badge_images: &[RgbaImage], poster_position:
|
| 193 |
let spacing = (BADGE_SPACING as f32 * badge_scale).round() as u32;
|
| 194 |
let row_spacing = (BADGE_ROW_SPACING as f32 * badge_scale).round() as u32;
|
| 195 |
let top_margin = (BADGE_TOP_MARGIN as f32 * badge_scale).round() as u32;
|
|
@@ -242,7 +242,7 @@ pub fn render_poster_sync(
|
|
| 242 |
badges: &[RatingBadge],
|
| 243 |
font: &FontArc,
|
| 244 |
quality: u8,
|
| 245 |
-
poster_position:
|
| 246 |
badge_style: BadgeStyle,
|
| 247 |
label_style: LabelStyle,
|
| 248 |
badge_direction: BadgeDirection,
|
|
@@ -578,7 +578,7 @@ mod tests {
|
|
| 578 |
)
|
| 579 |
.unwrap();
|
| 580 |
|
| 581 |
-
let result = render_poster_sync(&png_bytes, &[], &font, 85,
|
| 582 |
assert!(!result.is_empty());
|
| 583 |
// Should be valid JPEG
|
| 584 |
assert_eq!(result[0], 0xFF);
|
|
@@ -621,7 +621,7 @@ mod tests {
|
|
| 621 |
},
|
| 622 |
];
|
| 623 |
|
| 624 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 625 |
assert!(!result.is_empty());
|
| 626 |
assert_eq!(result[0], 0xFF);
|
| 627 |
assert_eq!(result[1], 0xD8);
|
|
@@ -630,7 +630,7 @@ mod tests {
|
|
| 630 |
#[test]
|
| 631 |
fn render_poster_invalid_image_bytes() {
|
| 632 |
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 633 |
-
let result = render_poster_sync(b"not an image", &[], &font, 85,
|
| 634 |
assert!(result.is_err());
|
| 635 |
}
|
| 636 |
|
|
@@ -749,11 +749,13 @@ mod tests {
|
|
| 749 |
value: "8.5".to_string(),
|
| 750 |
},
|
| 751 |
];
|
| 752 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 753 |
assert_eq!(result[0], 0xFF);
|
| 754 |
assert_eq!(result[1], 0xD8);
|
| 755 |
}
|
| 756 |
|
|
|
|
|
|
|
| 757 |
#[test]
|
| 758 |
fn render_poster_left_position_produces_valid_jpeg() {
|
| 759 |
use crate::services::ratings::{RatingBadge, RatingSource};
|
|
@@ -766,7 +768,7 @@ mod tests {
|
|
| 766 |
value: "8.5".to_string(),
|
| 767 |
},
|
| 768 |
];
|
| 769 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 770 |
assert_eq!(result[0], 0xFF);
|
| 771 |
assert_eq!(result[1], 0xD8);
|
| 772 |
}
|
|
@@ -783,7 +785,7 @@ mod tests {
|
|
| 783 |
value: "8.5".to_string(),
|
| 784 |
},
|
| 785 |
];
|
| 786 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 787 |
assert_eq!(result[0], 0xFF);
|
| 788 |
assert_eq!(result[1], 0xD8);
|
| 789 |
}
|
|
@@ -798,7 +800,7 @@ mod tests {
|
|
| 798 |
RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
|
| 799 |
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 800 |
];
|
| 801 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 802 |
assert_eq!(result[0], 0xFF);
|
| 803 |
assert_eq!(result[1], 0xD8);
|
| 804 |
}
|
|
@@ -814,17 +816,17 @@ mod tests {
|
|
| 814 |
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 815 |
];
|
| 816 |
// vertical direction at bottom-center
|
| 817 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 818 |
assert_eq!(result[0], 0xFF);
|
| 819 |
assert_eq!(result[1], 0xD8);
|
| 820 |
|
| 821 |
// vertical direction at top-left corner
|
| 822 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 823 |
assert_eq!(result[0], 0xFF);
|
| 824 |
assert_eq!(result[1], 0xD8);
|
| 825 |
|
| 826 |
// vertical direction at bottom-right corner
|
| 827 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 828 |
assert_eq!(result[0], 0xFF);
|
| 829 |
assert_eq!(result[1], 0xD8);
|
| 830 |
}
|
|
@@ -871,7 +873,7 @@ mod tests {
|
|
| 871 |
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 872 |
RatingBadge { source: RatingSource::RtAudience, value: "45%".to_string() },
|
| 873 |
];
|
| 874 |
-
let result = render_poster_sync(&png_bytes, &badges, &font, 85,
|
| 875 |
assert_eq!(result[0], 0xFF);
|
| 876 |
assert_eq!(result[1], 0xD8);
|
| 877 |
}
|
|
@@ -928,7 +930,7 @@ mod tests {
|
|
| 928 |
quality: 85,
|
| 929 |
cache_dir: "/tmp",
|
| 930 |
image_stale_secs: 3600,
|
| 931 |
-
poster_position:
|
| 932 |
badge_style: BadgeStyle::Horizontal,
|
| 933 |
label_style: LabelStyle::Text,
|
| 934 |
badge_direction: BadgeDirection::Horizontal,
|
|
@@ -963,7 +965,7 @@ mod tests {
|
|
| 963 |
quality: 85,
|
| 964 |
cache_dir: "/tmp",
|
| 965 |
image_stale_secs: 3600,
|
| 966 |
-
poster_position:
|
| 967 |
badge_style: BadgeStyle::Horizontal,
|
| 968 |
label_style: LabelStyle::Text,
|
| 969 |
badge_direction: BadgeDirection::Horizontal,
|
|
@@ -1058,7 +1060,7 @@ mod tests {
|
|
| 1058 |
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 1059 |
let png = test_png(500, 750);
|
| 1060 |
// Render at large size (1280 width, ~2.2x badge scale)
|
| 1061 |
-
let result = render_poster_sync(&png, &[], &font, 85,
|
| 1062 |
assert!(!result.is_empty());
|
| 1063 |
assert_eq!(result[0], 0xFF);
|
| 1064 |
assert_eq!(result[1], 0xD8);
|
|
@@ -1076,7 +1078,7 @@ mod tests {
|
|
| 1076 |
RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
|
| 1077 |
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 1078 |
];
|
| 1079 |
-
let result = render_poster_sync(&png, &badges, &font, 85,
|
| 1080 |
let img = image::load_from_memory(&result).unwrap();
|
| 1081 |
assert_eq!(img.width(), 1280);
|
| 1082 |
}
|
|
@@ -1092,16 +1094,114 @@ mod tests {
|
|
| 1092 |
RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
|
| 1093 |
];
|
| 1094 |
// Large badge size with horizontal style — should use max 2 per row
|
| 1095 |
-
let result = render_poster_sync(&png, &badges, &font, 85,
|
| 1096 |
assert_eq!(result[0], 0xFF);
|
| 1097 |
assert_eq!(result[1], 0xD8);
|
| 1098 |
|
| 1099 |
// Extra-large badge size with vertical style — should use max 4 per row
|
| 1100 |
-
let result = render_poster_sync(&png, &badges, &font, 85,
|
| 1101 |
assert_eq!(result[0], 0xFF);
|
| 1102 |
assert_eq!(result[1], 0xD8);
|
| 1103 |
}
|
| 1104 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1105 |
#[test]
|
| 1106 |
fn render_logo_at_large_target_width() {
|
| 1107 |
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
|
|
|
| 8 |
use crate::cache;
|
| 9 |
use crate::error::AppError;
|
| 10 |
use crate::image::badge;
|
| 11 |
+
use crate::services::db::{BadgeDirection, BadgeSize, BadgeStyle, LabelStyle, BadgePosition};
|
| 12 |
use crate::services::ratings::RatingBadge;
|
| 13 |
use crate::services::tmdb::TmdbClient;
|
| 14 |
|
|
|
|
| 34 |
pub cache_dir: &'a str,
|
| 35 |
pub image_stale_secs: u64,
|
| 36 |
pub poster_bytes_override: Option<Vec<u8>>,
|
| 37 |
+
pub poster_position: BadgePosition,
|
| 38 |
pub badge_style: BadgeStyle,
|
| 39 |
pub label_style: LabelStyle,
|
| 40 |
pub badge_direction: BadgeDirection,
|
|
|
|
| 141 |
}
|
| 142 |
|
| 143 |
/// Overlay badges in a vertical column, positioned according to `poster_position`.
|
| 144 |
+
fn overlay_vertical_stack(canvas: &mut RgbaImage, badge_images: &[RgbaImage], poster_position: BadgePosition, badge_scale: f32) {
|
| 145 |
let vert_spacing = (BADGE_VERT_SPACING as f32 * badge_scale).round() as u32;
|
| 146 |
let top_margin = (BADGE_TOP_MARGIN as f32 * badge_scale).round() as u32;
|
| 147 |
let bottom_margin = (BADGE_BOTTOM_MARGIN as f32 * badge_scale).round() as u32;
|
|
|
|
| 189 |
}
|
| 190 |
|
| 191 |
/// Overlay badges in horizontal rows, positioned according to `poster_position`.
|
| 192 |
+
fn overlay_horizontal_rows(canvas: &mut RgbaImage, badge_images: &[RgbaImage], poster_position: BadgePosition, max_per_row: usize, badge_scale: f32) {
|
| 193 |
let spacing = (BADGE_SPACING as f32 * badge_scale).round() as u32;
|
| 194 |
let row_spacing = (BADGE_ROW_SPACING as f32 * badge_scale).round() as u32;
|
| 195 |
let top_margin = (BADGE_TOP_MARGIN as f32 * badge_scale).round() as u32;
|
|
|
|
| 242 |
badges: &[RatingBadge],
|
| 243 |
font: &FontArc,
|
| 244 |
quality: u8,
|
| 245 |
+
poster_position: BadgePosition,
|
| 246 |
badge_style: BadgeStyle,
|
| 247 |
label_style: LabelStyle,
|
| 248 |
badge_direction: BadgeDirection,
|
|
|
|
| 578 |
)
|
| 579 |
.unwrap();
|
| 580 |
|
| 581 |
+
let result = render_poster_sync(&png_bytes, &[], &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 582 |
assert!(!result.is_empty());
|
| 583 |
// Should be valid JPEG
|
| 584 |
assert_eq!(result[0], 0xFF);
|
|
|
|
| 621 |
},
|
| 622 |
];
|
| 623 |
|
| 624 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 625 |
assert!(!result.is_empty());
|
| 626 |
assert_eq!(result[0], 0xFF);
|
| 627 |
assert_eq!(result[1], 0xD8);
|
|
|
|
| 630 |
#[test]
|
| 631 |
fn render_poster_invalid_image_bytes() {
|
| 632 |
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 633 |
+
let result = render_poster_sync(b"not an image", &[], &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium);
|
| 634 |
assert!(result.is_err());
|
| 635 |
}
|
| 636 |
|
|
|
|
| 749 |
value: "8.5".to_string(),
|
| 750 |
},
|
| 751 |
];
|
| 752 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::TopCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 753 |
assert_eq!(result[0], 0xFF);
|
| 754 |
assert_eq!(result[1], 0xD8);
|
| 755 |
}
|
| 756 |
|
| 757 |
+
|
| 758 |
+
|
| 759 |
#[test]
|
| 760 |
fn render_poster_left_position_produces_valid_jpeg() {
|
| 761 |
use crate::services::ratings::{RatingBadge, RatingSource};
|
|
|
|
| 768 |
value: "8.5".to_string(),
|
| 769 |
},
|
| 770 |
];
|
| 771 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::Left, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 772 |
assert_eq!(result[0], 0xFF);
|
| 773 |
assert_eq!(result[1], 0xD8);
|
| 774 |
}
|
|
|
|
| 785 |
value: "8.5".to_string(),
|
| 786 |
},
|
| 787 |
];
|
| 788 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::Right, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 789 |
assert_eq!(result[0], 0xFF);
|
| 790 |
assert_eq!(result[1], 0xD8);
|
| 791 |
}
|
|
|
|
| 800 |
RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
|
| 801 |
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 802 |
];
|
| 803 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Icon, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 804 |
assert_eq!(result[0], 0xFF);
|
| 805 |
assert_eq!(result[1], 0xD8);
|
| 806 |
}
|
|
|
|
| 816 |
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 817 |
];
|
| 818 |
// vertical direction at bottom-center
|
| 819 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 820 |
assert_eq!(result[0], 0xFF);
|
| 821 |
assert_eq!(result[1], 0xD8);
|
| 822 |
|
| 823 |
// vertical direction at top-left corner
|
| 824 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::TopLeft, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 825 |
assert_eq!(result[0], 0xFF);
|
| 826 |
assert_eq!(result[1], 0xD8);
|
| 827 |
|
| 828 |
// vertical direction at bottom-right corner
|
| 829 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 830 |
assert_eq!(result[0], 0xFF);
|
| 831 |
assert_eq!(result[1], 0xD8);
|
| 832 |
}
|
|
|
|
| 873 |
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 874 |
RatingBadge { source: RatingSource::RtAudience, value: "45%".to_string() },
|
| 875 |
];
|
| 876 |
+
let result = render_poster_sync(&png_bytes, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Official, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 877 |
assert_eq!(result[0], 0xFF);
|
| 878 |
assert_eq!(result[1], 0xD8);
|
| 879 |
}
|
|
|
|
| 930 |
quality: 85,
|
| 931 |
cache_dir: "/tmp",
|
| 932 |
image_stale_secs: 3600,
|
| 933 |
+
poster_position: BadgePosition::BottomCenter,
|
| 934 |
badge_style: BadgeStyle::Horizontal,
|
| 935 |
label_style: LabelStyle::Text,
|
| 936 |
badge_direction: BadgeDirection::Horizontal,
|
|
|
|
| 965 |
quality: 85,
|
| 966 |
cache_dir: "/tmp",
|
| 967 |
image_stale_secs: 3600,
|
| 968 |
+
poster_position: BadgePosition::BottomCenter,
|
| 969 |
badge_style: BadgeStyle::Horizontal,
|
| 970 |
label_style: LabelStyle::Text,
|
| 971 |
badge_direction: BadgeDirection::Horizontal,
|
|
|
|
| 1060 |
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 1061 |
let png = test_png(500, 750);
|
| 1062 |
// Render at large size (1280 width, ~2.2x badge scale)
|
| 1063 |
+
let result = render_poster_sync(&png, &[], &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 1280, 2.2, BadgeSize::Medium).unwrap();
|
| 1064 |
assert!(!result.is_empty());
|
| 1065 |
assert_eq!(result[0], 0xFF);
|
| 1066 |
assert_eq!(result[1], 0xD8);
|
|
|
|
| 1078 |
RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
|
| 1079 |
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 1080 |
];
|
| 1081 |
+
let result = render_poster_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 1280, 2.2, BadgeSize::Medium).unwrap();
|
| 1082 |
let img = image::load_from_memory(&result).unwrap();
|
| 1083 |
assert_eq!(img.width(), 1280);
|
| 1084 |
}
|
|
|
|
| 1094 |
RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
|
| 1095 |
];
|
| 1096 |
// Large badge size with horizontal style — should use max 2 per row
|
| 1097 |
+
let result = render_poster_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Large).unwrap();
|
| 1098 |
assert_eq!(result[0], 0xFF);
|
| 1099 |
assert_eq!(result[1], 0xD8);
|
| 1100 |
|
| 1101 |
// Extra-large badge size with vertical style — should use max 4 per row
|
| 1102 |
+
let result = render_poster_sync(&png, &badges, &font, 85, BadgePosition::BottomCenter, BadgeStyle::Vertical, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::ExtraLarge).unwrap();
|
| 1103 |
assert_eq!(result[0], 0xFF);
|
| 1104 |
assert_eq!(result[1], 0xD8);
|
| 1105 |
}
|
| 1106 |
|
| 1107 |
+
/// Compute the centroid (center of mass) of non-background pixels in a
|
| 1108 |
+
/// rendered poster JPEG. The base image is uniform gray (128,128,128), so
|
| 1109 |
+
/// any pixel that deviates significantly is part of a badge overlay.
|
| 1110 |
+
/// Returns (centroid_x, centroid_y) as fractions of image dimensions (0.0–1.0).
|
| 1111 |
+
fn badge_centroid(jpeg_bytes: &[u8]) -> (f64, f64) {
|
| 1112 |
+
let img = image::load_from_memory(jpeg_bytes).unwrap().to_rgba8();
|
| 1113 |
+
let (w, h) = (img.width() as f64, img.height() as f64);
|
| 1114 |
+
let (mut sx, mut sy, mut count) = (0u64, 0u64, 0u64);
|
| 1115 |
+
for (x, y, px) in img.enumerate_pixels() {
|
| 1116 |
+
// JPEG compression blurs edges, so use a generous threshold
|
| 1117 |
+
let diff = (px[0] as i32 - 128).abs()
|
| 1118 |
+
.max((px[1] as i32 - 128).abs())
|
| 1119 |
+
.max((px[2] as i32 - 128).abs());
|
| 1120 |
+
if diff > 20 {
|
| 1121 |
+
sx += x as u64;
|
| 1122 |
+
sy += y as u64;
|
| 1123 |
+
count += 1;
|
| 1124 |
+
}
|
| 1125 |
+
}
|
| 1126 |
+
assert!(count > 0, "no badge pixels found");
|
| 1127 |
+
(sx as f64 / count as f64 / w, sy as f64 / count as f64 / h)
|
| 1128 |
+
}
|
| 1129 |
+
|
| 1130 |
+
fn position_test_badges() -> Vec<crate::services::ratings::RatingBadge> {
|
| 1131 |
+
use crate::services::ratings::{RatingBadge, RatingSource};
|
| 1132 |
+
vec![
|
| 1133 |
+
RatingBadge { source: RatingSource::Imdb, value: "8.5".to_string() },
|
| 1134 |
+
RatingBadge { source: RatingSource::Tmdb, value: "85%".to_string() },
|
| 1135 |
+
RatingBadge { source: RatingSource::Rt, value: "92%".to_string() },
|
| 1136 |
+
]
|
| 1137 |
+
}
|
| 1138 |
+
|
| 1139 |
+
#[test]
|
| 1140 |
+
fn badge_position_top_center_places_badges_in_top_region() {
|
| 1141 |
+
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 1142 |
+
let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
|
| 1143 |
+
BadgePosition::TopCenter, BadgeStyle::Horizontal, LabelStyle::Text,
|
| 1144 |
+
BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 1145 |
+
let (cx, cy) = badge_centroid(&result);
|
| 1146 |
+
assert!(cy < 0.33, "TopCenter: badge y-centroid {cy:.2} should be in top third");
|
| 1147 |
+
assert!(cx > 0.3 && cx < 0.7, "TopCenter: badge x-centroid {cx:.2} should be centered");
|
| 1148 |
+
}
|
| 1149 |
+
|
| 1150 |
+
#[test]
|
| 1151 |
+
fn badge_position_bottom_center_places_badges_in_bottom_region() {
|
| 1152 |
+
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 1153 |
+
let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
|
| 1154 |
+
BadgePosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text,
|
| 1155 |
+
BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 1156 |
+
let (cx, cy) = badge_centroid(&result);
|
| 1157 |
+
assert!(cy > 0.67, "BottomCenter: badge y-centroid {cy:.2} should be in bottom third");
|
| 1158 |
+
assert!(cx > 0.3 && cx < 0.7, "BottomCenter: badge x-centroid {cx:.2} should be centered");
|
| 1159 |
+
}
|
| 1160 |
+
|
| 1161 |
+
#[test]
|
| 1162 |
+
fn badge_position_left_places_badges_on_left_side() {
|
| 1163 |
+
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 1164 |
+
let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
|
| 1165 |
+
BadgePosition::Left, BadgeStyle::Horizontal, LabelStyle::Text,
|
| 1166 |
+
BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 1167 |
+
let (cx, cy) = badge_centroid(&result);
|
| 1168 |
+
assert!(cx < 0.5, "Left: badge x-centroid {cx:.2} should be in left half");
|
| 1169 |
+
assert!(cy > 0.25 && cy < 0.75, "Left: badge y-centroid {cy:.2} should be vertically centered");
|
| 1170 |
+
}
|
| 1171 |
+
|
| 1172 |
+
#[test]
|
| 1173 |
+
fn badge_position_right_places_badges_on_right_side() {
|
| 1174 |
+
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 1175 |
+
let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
|
| 1176 |
+
BadgePosition::Right, BadgeStyle::Horizontal, LabelStyle::Text,
|
| 1177 |
+
BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 1178 |
+
let (cx, cy) = badge_centroid(&result);
|
| 1179 |
+
assert!(cx > 0.5, "Right: badge x-centroid {cx:.2} should be in right half");
|
| 1180 |
+
assert!(cy > 0.25 && cy < 0.75, "Right: badge y-centroid {cy:.2} should be vertically centered");
|
| 1181 |
+
}
|
| 1182 |
+
|
| 1183 |
+
#[test]
|
| 1184 |
+
fn badge_position_top_left_places_badges_in_top_left_quadrant() {
|
| 1185 |
+
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 1186 |
+
let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
|
| 1187 |
+
BadgePosition::TopLeft, BadgeStyle::Horizontal, LabelStyle::Text,
|
| 1188 |
+
BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 1189 |
+
let (cx, cy) = badge_centroid(&result);
|
| 1190 |
+
assert!(cx < 0.5, "TopLeft: badge x-centroid {cx:.2} should be in left half");
|
| 1191 |
+
assert!(cy < 0.5, "TopLeft: badge y-centroid {cy:.2} should be in top half");
|
| 1192 |
+
}
|
| 1193 |
+
|
| 1194 |
+
#[test]
|
| 1195 |
+
fn badge_position_bottom_right_places_badges_in_bottom_right_quadrant() {
|
| 1196 |
+
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
| 1197 |
+
let result = render_poster_sync(&test_png(500, 750), &position_test_badges(), &font, 85,
|
| 1198 |
+
BadgePosition::BottomRight, BadgeStyle::Horizontal, LabelStyle::Text,
|
| 1199 |
+
BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
|
| 1200 |
+
let (cx, cy) = badge_centroid(&result);
|
| 1201 |
+
assert!(cx > 0.5, "BottomRight: badge x-centroid {cx:.2} should be in right half");
|
| 1202 |
+
assert!(cy > 0.5, "BottomRight: badge y-centroid {cy:.2} should be in bottom half");
|
| 1203 |
+
}
|
| 1204 |
+
|
| 1205 |
#[test]
|
| 1206 |
fn render_logo_at_large_target_width() {
|
| 1207 |
let font = FontArc::try_from_slice(crate::FONT_BYTES).unwrap();
|
api/src/image/serve.rs
CHANGED
|
@@ -10,7 +10,7 @@ use crate::cache::{self, MemCacheEntry};
|
|
| 10 |
use crate::error::AppError;
|
| 11 |
use crate::id::{self, IdType, MediaType, format_tmdb_id_value};
|
| 12 |
use crate::image::generate;
|
| 13 |
-
use crate::services::db::{BadgeStyle, ImageSize, LabelStyle, RenderSettings};
|
| 14 |
use crate::services::fanart::{FanartClient, FanartImages, FanartPoster, PosterMatch};
|
| 15 |
use crate::services::ratings;
|
| 16 |
use crate::AppState;
|
|
@@ -120,7 +120,7 @@ pub fn settings_cache_suffix_with_ratings(
|
|
| 120 |
poster_badge_size: _,
|
| 121 |
logo_badge_size: _,
|
| 122 |
backdrop_badge_size: _,
|
| 123 |
-
|
| 124 |
} = settings;
|
| 125 |
|
| 126 |
let resolved_size = resolve_image_size(image_size);
|
|
@@ -174,7 +174,7 @@ pub fn settings_hash(settings: &RenderSettings, kind: cache::ImageType, image_si
|
|
| 174 |
hasher.update(b"\0");
|
| 175 |
hasher.update(if settings.fanart_textless { b"1" } else { b"0" });
|
| 176 |
hasher.update(b"\0");
|
| 177 |
-
hasher.update(if settings.
|
| 178 |
|
| 179 |
let hash = hasher.finalize();
|
| 180 |
format!(
|
|
@@ -501,7 +501,7 @@ pub async fn handle_inner(
|
|
| 501 |
settings.poster_badge_direction = settings.poster_badge_direction.resolve(settings.poster_position);
|
| 502 |
settings.poster_badge_style = settings.poster_badge_style.resolve(settings.poster_badge_direction);
|
| 503 |
|
| 504 |
-
let use_fanart = settings.poster_source.is_fanart() || settings.
|
| 505 |
let id_key = format!("{id_type_str}/{id_value}");
|
| 506 |
|
| 507 |
// Fast path (non-fanart): try to reconstruct the cache key from SQLite-stored
|
|
@@ -573,14 +573,14 @@ pub async fn handle_inner(
|
|
| 573 |
|
| 574 |
// Fanart → TMDB fallback strategy:
|
| 575 |
//
|
| 576 |
-
// 1. If the user's source is fanart, or
|
| 577 |
-
//
|
| 578 |
//
|
| 579 |
// 2. On fanart miss, fall through to TMDB. The settings used for TMDB depend
|
| 580 |
// on *why* we tried fanart:
|
| 581 |
-
// a.
|
| 582 |
-
// (badge style, position, etc.) for the TMDB fallback; just
|
| 583 |
-
// the
|
| 584 |
// b. Fanart-source user — reset to defaults, since their per-key settings
|
| 585 |
// (e.g. fanart-specific lang/textless) don't apply to TMDB posters.
|
| 586 |
if use_fanart {
|
|
@@ -591,8 +591,8 @@ pub async fn handle_inner(
|
|
| 591 |
|
| 592 |
// TMDB path (default, or fanart fallback)
|
| 593 |
if use_fanart {
|
| 594 |
-
if settings.
|
| 595 |
-
settings.
|
| 596 |
} else {
|
| 597 |
let mut defaults = RenderSettings::default();
|
| 598 |
defaults.poster_badge_direction = defaults.poster_badge_direction.resolve(defaults.poster_position);
|
|
@@ -1031,7 +1031,7 @@ async fn generate_poster_with_source(
|
|
| 1031 |
})?;
|
| 1032 |
|
| 1033 |
// Try to fetch poster bytes from fanart.tv if configured
|
| 1034 |
-
let fanart_result = if settings.poster_source.is_fanart() || settings.
|
| 1035 |
if let Some(ref fanart) = state.fanart {
|
| 1036 |
fetch_fanart_image(
|
| 1037 |
fanart,
|
|
@@ -1252,7 +1252,8 @@ pub async fn handle_fanart_image_inner(
|
|
| 1252 |
let type_badge_style = match fanart_kind {
|
| 1253 |
FanartImageKind::Logo => settings.logo_badge_style,
|
| 1254 |
FanartImageKind::Backdrop => settings.backdrop_badge_style,
|
| 1255 |
-
}
|
|
|
|
| 1256 |
let type_label_style = match fanart_kind {
|
| 1257 |
FanartImageKind::Logo => settings.logo_label_style,
|
| 1258 |
FanartImageKind::Backdrop => settings.backdrop_label_style,
|
|
@@ -1615,13 +1616,13 @@ mod tests {
|
|
| 1615 |
}
|
| 1616 |
|
| 1617 |
#[test]
|
| 1618 |
-
fn
|
| 1619 |
let mut s1 = RenderSettings::default();
|
| 1620 |
let mut s2 = RenderSettings::default();
|
| 1621 |
s1.fanart_lang = "de".into();
|
| 1622 |
-
s1.
|
| 1623 |
s2.fanart_lang = "de".into();
|
| 1624 |
-
s2.
|
| 1625 |
assert_ne!(
|
| 1626 |
settings_hash(&s1, cache::ImageType::Poster, None),
|
| 1627 |
settings_hash(&s2, cache::ImageType::Poster, None)
|
|
@@ -1743,8 +1744,8 @@ mod tests {
|
|
| 1743 |
s2.fanart_lang = "de".into();
|
| 1744 |
s1.fanart_textless = false;
|
| 1745 |
s2.fanart_textless = true;
|
| 1746 |
-
s1.
|
| 1747 |
-
s2.
|
| 1748 |
assert_eq!(
|
| 1749 |
settings_cache_suffix(&s1, cache::ImageType::Poster, None),
|
| 1750 |
settings_cache_suffix(&s2, cache::ImageType::Poster, None)
|
|
|
|
| 10 |
use crate::error::AppError;
|
| 11 |
use crate::id::{self, IdType, MediaType, format_tmdb_id_value};
|
| 12 |
use crate::image::generate;
|
| 13 |
+
use crate::services::db::{BadgeDirection, BadgeStyle, ImageSize, LabelStyle, RenderSettings};
|
| 14 |
use crate::services::fanart::{FanartClient, FanartImages, FanartPoster, PosterMatch};
|
| 15 |
use crate::services::ratings;
|
| 16 |
use crate::AppState;
|
|
|
|
| 120 |
poster_badge_size: _,
|
| 121 |
logo_badge_size: _,
|
| 122 |
backdrop_badge_size: _,
|
| 123 |
+
fanart_override: _, // handled by code path, not suffix
|
| 124 |
} = settings;
|
| 125 |
|
| 126 |
let resolved_size = resolve_image_size(image_size);
|
|
|
|
| 174 |
hasher.update(b"\0");
|
| 175 |
hasher.update(if settings.fanart_textless { b"1" } else { b"0" });
|
| 176 |
hasher.update(b"\0");
|
| 177 |
+
hasher.update(if settings.fanart_override { b"1" } else { b"0" });
|
| 178 |
|
| 179 |
let hash = hasher.finalize();
|
| 180 |
format!(
|
|
|
|
| 501 |
settings.poster_badge_direction = settings.poster_badge_direction.resolve(settings.poster_position);
|
| 502 |
settings.poster_badge_style = settings.poster_badge_style.resolve(settings.poster_badge_direction);
|
| 503 |
|
| 504 |
+
let use_fanart = settings.poster_source.is_fanart() || settings.fanart_override;
|
| 505 |
let id_key = format!("{id_type_str}/{id_value}");
|
| 506 |
|
| 507 |
// Fast path (non-fanart): try to reconstruct the cache key from SQLite-stored
|
|
|
|
| 573 |
|
| 574 |
// Fanart → TMDB fallback strategy:
|
| 575 |
//
|
| 576 |
+
// 1. If the user's source is fanart, or a query param forced the fanart path
|
| 577 |
+
// (e.g. `?lang=`, `?fanart_textless=true`), try fanart first. On hit, return.
|
| 578 |
//
|
| 579 |
// 2. On fanart miss, fall through to TMDB. The settings used for TMDB depend
|
| 580 |
// on *why* we tried fanart:
|
| 581 |
+
// a. Query-param override on a TMDB user — preserve the user's original
|
| 582 |
+
// settings (badge style, position, etc.) for the TMDB fallback; just
|
| 583 |
+
// clear the fanart_override flag so we don't re-enter the fanart path.
|
| 584 |
// b. Fanart-source user — reset to defaults, since their per-key settings
|
| 585 |
// (e.g. fanart-specific lang/textless) don't apply to TMDB posters.
|
| 586 |
if use_fanart {
|
|
|
|
| 591 |
|
| 592 |
// TMDB path (default, or fanart fallback)
|
| 593 |
if use_fanart {
|
| 594 |
+
if settings.fanart_override && !settings.poster_source.is_fanart() {
|
| 595 |
+
settings.fanart_override = false;
|
| 596 |
} else {
|
| 597 |
let mut defaults = RenderSettings::default();
|
| 598 |
defaults.poster_badge_direction = defaults.poster_badge_direction.resolve(defaults.poster_position);
|
|
|
|
| 1031 |
})?;
|
| 1032 |
|
| 1033 |
// Try to fetch poster bytes from fanart.tv if configured
|
| 1034 |
+
let fanart_result = if settings.poster_source.is_fanart() || settings.fanart_override {
|
| 1035 |
if let Some(ref fanart) = state.fanart {
|
| 1036 |
fetch_fanart_image(
|
| 1037 |
fanart,
|
|
|
|
| 1252 |
let type_badge_style = match fanart_kind {
|
| 1253 |
FanartImageKind::Logo => settings.logo_badge_style,
|
| 1254 |
FanartImageKind::Backdrop => settings.backdrop_badge_style,
|
| 1255 |
+
}
|
| 1256 |
+
.resolve(BadgeDirection::Vertical);
|
| 1257 |
let type_label_style = match fanart_kind {
|
| 1258 |
FanartImageKind::Logo => settings.logo_label_style,
|
| 1259 |
FanartImageKind::Backdrop => settings.backdrop_label_style,
|
|
|
|
| 1616 |
}
|
| 1617 |
|
| 1618 |
#[test]
|
| 1619 |
+
fn settings_hash_includes_fanart_override() {
|
| 1620 |
let mut s1 = RenderSettings::default();
|
| 1621 |
let mut s2 = RenderSettings::default();
|
| 1622 |
s1.fanart_lang = "de".into();
|
| 1623 |
+
s1.fanart_override = false;
|
| 1624 |
s2.fanart_lang = "de".into();
|
| 1625 |
+
s2.fanart_override = true;
|
| 1626 |
assert_ne!(
|
| 1627 |
settings_hash(&s1, cache::ImageType::Poster, None),
|
| 1628 |
settings_hash(&s2, cache::ImageType::Poster, None)
|
|
|
|
| 1744 |
s2.fanart_lang = "de".into();
|
| 1745 |
s1.fanart_textless = false;
|
| 1746 |
s2.fanart_textless = true;
|
| 1747 |
+
s1.fanart_override = false;
|
| 1748 |
+
s2.fanart_override = true;
|
| 1749 |
assert_eq!(
|
| 1750 |
settings_cache_suffix(&s1, cache::ImageType::Poster, None),
|
| 1751 |
settings_cache_suffix(&s2, cache::ImageType::Poster, None)
|
api/src/lib.rs
CHANGED
|
@@ -268,4 +268,8 @@ pub const MIGRATIONS: &[(&str, &str)] = &[
|
|
| 268 |
"ALTER TABLE api_key_settings ADD COLUMN backdrop_badge_size TEXT NOT NULL DEFAULT 'm'",
|
| 269 |
"duplicate column",
|
| 270 |
),
|
|
|
|
|
|
|
|
|
|
|
|
|
| 271 |
];
|
|
|
|
| 268 |
"ALTER TABLE api_key_settings ADD COLUMN backdrop_badge_size TEXT NOT NULL DEFAULT 'm'",
|
| 269 |
"duplicate column",
|
| 270 |
),
|
| 271 |
+
(
|
| 272 |
+
"CREATE INDEX IF NOT EXISTS idx_image_meta_type ON image_meta(image_type)",
|
| 273 |
+
"already exists",
|
| 274 |
+
),
|
| 275 |
];
|
api/src/services/db.rs
CHANGED
|
@@ -80,8 +80,10 @@ impl BadgeStyle {
|
|
| 80 |
}
|
| 81 |
}
|
| 82 |
|
|
|
|
|
|
|
|
|
|
| 83 |
pub fn is_vertical(self) -> bool {
|
| 84 |
-
debug_assert!(self != Self::Default, "BadgeStyle::Default should be resolved before checking is_vertical");
|
| 85 |
self == Self::Vertical
|
| 86 |
}
|
| 87 |
|
|
@@ -130,13 +132,15 @@ impl BadgeDirection {
|
|
| 130 |
}
|
| 131 |
}
|
| 132 |
|
|
|
|
|
|
|
|
|
|
| 133 |
pub fn is_vertical(self) -> bool {
|
| 134 |
-
debug_assert!(self != Self::Default, "BadgeDirection::Default should be resolved before checking is_vertical");
|
| 135 |
self == Self::Vertical
|
| 136 |
}
|
| 137 |
|
| 138 |
/// Resolve `Default` to `Horizontal` or `Vertical` based on poster position.
|
| 139 |
-
pub fn resolve(self, position:
|
| 140 |
if self != Self::Default {
|
| 141 |
return self;
|
| 142 |
}
|
|
@@ -151,7 +155,7 @@ impl BadgeDirection {
|
|
| 151 |
impl_str_enum!(BadgeDirection);
|
| 152 |
|
| 153 |
const DIRECTION_DEFAULT: &str = "d";
|
| 154 |
-
const STYLE_DEFAULT: &str =
|
| 155 |
|
| 156 |
const LABEL_ICON: &str = "i";
|
| 157 |
const LABEL_TEXT: &str = "t";
|
|
@@ -223,7 +227,7 @@ impl PosterSource {
|
|
| 223 |
impl_str_enum!(PosterSource);
|
| 224 |
|
| 225 |
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
| 226 |
-
pub enum
|
| 227 |
BottomCenter,
|
| 228 |
TopCenter,
|
| 229 |
Left,
|
|
@@ -234,7 +238,7 @@ pub enum PosterPosition {
|
|
| 234 |
BottomRight,
|
| 235 |
}
|
| 236 |
|
| 237 |
-
impl
|
| 238 |
pub fn as_str(&self) -> &'static str {
|
| 239 |
match self {
|
| 240 |
Self::BottomCenter => POS_BOTTOM_CENTER,
|
|
@@ -285,7 +289,7 @@ impl PosterPosition {
|
|
| 285 |
}
|
| 286 |
}
|
| 287 |
|
| 288 |
-
impl_str_enum!(
|
| 289 |
|
| 290 |
const POS_BOTTOM_CENTER: &str = "bc";
|
| 291 |
const POS_TOP_CENTER: &str = "tc";
|
|
@@ -421,8 +425,8 @@ pub fn default_ratings_order() -> String {
|
|
| 421 |
"mal,imdb,lb,rt,mc,rta,tmdb,trakt".to_string()
|
| 422 |
}
|
| 423 |
|
| 424 |
-
pub fn default_poster_position() ->
|
| 425 |
-
|
| 426 |
}
|
| 427 |
|
| 428 |
pub fn default_poster_badge_style() -> BadgeStyle {
|
|
@@ -781,27 +785,27 @@ mod tests {
|
|
| 781 |
|
| 782 |
#[test]
|
| 783 |
fn validate_poster_position_accepts_valid() {
|
| 784 |
-
assert!(
|
| 785 |
-
assert!(
|
| 786 |
-
assert!(
|
| 787 |
-
assert!(
|
| 788 |
-
assert!(
|
| 789 |
-
assert!(
|
| 790 |
-
assert!(
|
| 791 |
-
assert!(
|
| 792 |
}
|
| 793 |
|
| 794 |
#[test]
|
| 795 |
fn validate_poster_position_rejects_invalid() {
|
| 796 |
-
assert!(
|
| 797 |
-
assert!(
|
| 798 |
-
assert!(
|
| 799 |
-
assert!(
|
| 800 |
}
|
| 801 |
|
| 802 |
#[test]
|
| 803 |
fn default_poster_position_returns_bottom_center() {
|
| 804 |
-
assert_eq!(default_poster_position(),
|
| 805 |
}
|
| 806 |
|
| 807 |
#[test]
|
|
@@ -877,28 +881,28 @@ mod tests {
|
|
| 877 |
|
| 878 |
#[test]
|
| 879 |
fn resolve_badge_direction_default_center_positions() {
|
| 880 |
-
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(
|
| 881 |
-
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(
|
| 882 |
}
|
| 883 |
|
| 884 |
#[test]
|
| 885 |
fn resolve_badge_direction_default_side_positions() {
|
| 886 |
-
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(
|
| 887 |
-
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(
|
| 888 |
}
|
| 889 |
|
| 890 |
#[test]
|
| 891 |
fn resolve_badge_direction_default_corner_positions() {
|
| 892 |
-
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(
|
| 893 |
-
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(
|
| 894 |
-
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(
|
| 895 |
-
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(
|
| 896 |
}
|
| 897 |
|
| 898 |
#[test]
|
| 899 |
fn resolve_badge_direction_explicit_passes_through() {
|
| 900 |
-
assert_eq!(BadgeDirection::parse("h").unwrap().resolve(
|
| 901 |
-
assert_eq!(BadgeDirection::parse("v").unwrap().resolve(
|
| 902 |
}
|
| 903 |
|
| 904 |
// --- ImageSize tests ---
|
|
@@ -1005,6 +1009,212 @@ mod tests {
|
|
| 1005 |
assert!(validate_image_size("huge", crate::cache::ImageType::Poster).is_err());
|
| 1006 |
assert!(validate_image_size("", crate::cache::ImageType::Backdrop).is_err());
|
| 1007 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1008 |
}
|
| 1009 |
|
| 1010 |
// --- Admin user CRUD ---
|
|
@@ -1463,7 +1673,7 @@ pub struct RenderSettings {
|
|
| 1463 |
pub ratings_limit: i32,
|
| 1464 |
pub ratings_order: Arc<str>,
|
| 1465 |
pub is_default: bool,
|
| 1466 |
-
pub poster_position:
|
| 1467 |
pub logo_ratings_limit: i32,
|
| 1468 |
pub backdrop_ratings_limit: i32,
|
| 1469 |
pub poster_badge_style: BadgeStyle,
|
|
@@ -1476,9 +1686,9 @@ pub struct RenderSettings {
|
|
| 1476 |
pub poster_badge_size: BadgeSize,
|
| 1477 |
pub logo_badge_size: BadgeSize,
|
| 1478 |
pub backdrop_badge_size: BadgeSize,
|
| 1479 |
-
/// Set when `?lang=`
|
| 1480 |
#[serde(skip)]
|
| 1481 |
-
pub
|
| 1482 |
}
|
| 1483 |
|
| 1484 |
impl Default for RenderSettings {
|
|
@@ -1490,7 +1700,7 @@ impl Default for RenderSettings {
|
|
| 1490 |
ratings_limit: default_ratings_limit(),
|
| 1491 |
ratings_order: Arc::from("mal,imdb,lb,rt,mc,rta,tmdb,trakt"),
|
| 1492 |
is_default: true,
|
| 1493 |
-
poster_position:
|
| 1494 |
logo_ratings_limit: default_logo_backdrop_ratings_limit(),
|
| 1495 |
backdrop_ratings_limit: default_logo_backdrop_ratings_limit(),
|
| 1496 |
poster_badge_style: BadgeStyle::Default,
|
|
@@ -1503,7 +1713,7 @@ impl Default for RenderSettings {
|
|
| 1503 |
poster_badge_size: BadgeSize::Medium,
|
| 1504 |
logo_badge_size: BadgeSize::Medium,
|
| 1505 |
backdrop_badge_size: BadgeSize::Medium,
|
| 1506 |
-
|
| 1507 |
}
|
| 1508 |
}
|
| 1509 |
}
|
|
@@ -1534,7 +1744,7 @@ pub fn parse_global_render_settings(globals: &HashMap<String, String>) -> Render
|
|
| 1534 |
.unwrap_or(defaults.ratings_limit),
|
| 1535 |
ratings_order: arc_or("ratings_order", defaults.ratings_order),
|
| 1536 |
is_default: true,
|
| 1537 |
-
poster_position: global_or(globals, "poster_position",
|
| 1538 |
logo_ratings_limit: globals
|
| 1539 |
.get("logo_ratings_limit")
|
| 1540 |
.and_then(|v| v.parse().ok())
|
|
@@ -1553,7 +1763,7 @@ pub fn parse_global_render_settings(globals: &HashMap<String, String>) -> Render
|
|
| 1553 |
poster_badge_size: global_or(globals, "poster_badge_size", BadgeSize::parse, defaults.poster_badge_size),
|
| 1554 |
logo_badge_size: global_or(globals, "logo_badge_size", BadgeSize::parse, defaults.logo_badge_size),
|
| 1555 |
backdrop_badge_size: global_or(globals, "backdrop_badge_size", BadgeSize::parse, defaults.backdrop_badge_size),
|
| 1556 |
-
|
| 1557 |
}
|
| 1558 |
}
|
| 1559 |
|
|
@@ -1572,7 +1782,7 @@ pub async fn get_effective_render_settings(
|
|
| 1572 |
ratings_limit: s.ratings_limit,
|
| 1573 |
ratings_order: Arc::from(s.ratings_order.as_str()),
|
| 1574 |
is_default: false,
|
| 1575 |
-
poster_position: parse_setting_or_default(&s.poster_position, "poster_position",
|
| 1576 |
logo_ratings_limit: s.logo_ratings_limit,
|
| 1577 |
backdrop_ratings_limit: s.backdrop_ratings_limit,
|
| 1578 |
poster_badge_style: parse_setting_or_default(&s.poster_badge_style, "poster_badge_style", BadgeStyle::parse, BadgeStyle::Default),
|
|
@@ -1585,7 +1795,7 @@ pub async fn get_effective_render_settings(
|
|
| 1585 |
poster_badge_size: parse_setting_or_default(&s.poster_badge_size, "poster_badge_size", BadgeSize::parse, BadgeSize::Medium),
|
| 1586 |
logo_badge_size: parse_setting_or_default(&s.logo_badge_size, "logo_badge_size", BadgeSize::parse, BadgeSize::Medium),
|
| 1587 |
backdrop_badge_size: parse_setting_or_default(&s.backdrop_badge_size, "backdrop_badge_size", BadgeSize::parse, BadgeSize::Medium),
|
| 1588 |
-
|
| 1589 |
};
|
| 1590 |
}
|
| 1591 |
Ok(None) => {} // no per-key override, fall through
|
|
|
|
| 80 |
}
|
| 81 |
}
|
| 82 |
|
| 83 |
+
/// Returns `true` if the style is vertical.
|
| 84 |
+
/// `Default` is treated as non-vertical (horizontal is the safe fallback).
|
| 85 |
+
/// Callers should resolve `Default` via `.resolve()` before calling this.
|
| 86 |
pub fn is_vertical(self) -> bool {
|
|
|
|
| 87 |
self == Self::Vertical
|
| 88 |
}
|
| 89 |
|
|
|
|
| 132 |
}
|
| 133 |
}
|
| 134 |
|
| 135 |
+
/// Returns `true` if the direction is vertical.
|
| 136 |
+
/// `Default` is treated as non-vertical (horizontal is the safe fallback).
|
| 137 |
+
/// Callers should resolve `Default` via `.resolve()` before calling this.
|
| 138 |
pub fn is_vertical(self) -> bool {
|
|
|
|
| 139 |
self == Self::Vertical
|
| 140 |
}
|
| 141 |
|
| 142 |
/// Resolve `Default` to `Horizontal` or `Vertical` based on poster position.
|
| 143 |
+
pub fn resolve(self, position: BadgePosition) -> Self {
|
| 144 |
if self != Self::Default {
|
| 145 |
return self;
|
| 146 |
}
|
|
|
|
| 155 |
impl_str_enum!(BadgeDirection);
|
| 156 |
|
| 157 |
const DIRECTION_DEFAULT: &str = "d";
|
| 158 |
+
const STYLE_DEFAULT: &str = "d";
|
| 159 |
|
| 160 |
const LABEL_ICON: &str = "i";
|
| 161 |
const LABEL_TEXT: &str = "t";
|
|
|
|
| 227 |
impl_str_enum!(PosterSource);
|
| 228 |
|
| 229 |
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
| 230 |
+
pub enum BadgePosition {
|
| 231 |
BottomCenter,
|
| 232 |
TopCenter,
|
| 233 |
Left,
|
|
|
|
| 238 |
BottomRight,
|
| 239 |
}
|
| 240 |
|
| 241 |
+
impl BadgePosition {
|
| 242 |
pub fn as_str(&self) -> &'static str {
|
| 243 |
match self {
|
| 244 |
Self::BottomCenter => POS_BOTTOM_CENTER,
|
|
|
|
| 289 |
}
|
| 290 |
}
|
| 291 |
|
| 292 |
+
impl_str_enum!(BadgePosition);
|
| 293 |
|
| 294 |
const POS_BOTTOM_CENTER: &str = "bc";
|
| 295 |
const POS_TOP_CENTER: &str = "tc";
|
|
|
|
| 425 |
"mal,imdb,lb,rt,mc,rta,tmdb,trakt".to_string()
|
| 426 |
}
|
| 427 |
|
| 428 |
+
pub fn default_poster_position() -> BadgePosition {
|
| 429 |
+
BadgePosition::BottomCenter
|
| 430 |
}
|
| 431 |
|
| 432 |
pub fn default_poster_badge_style() -> BadgeStyle {
|
|
|
|
| 785 |
|
| 786 |
#[test]
|
| 787 |
fn validate_poster_position_accepts_valid() {
|
| 788 |
+
assert!(BadgePosition::parse("bc").is_ok());
|
| 789 |
+
assert!(BadgePosition::parse("tc").is_ok());
|
| 790 |
+
assert!(BadgePosition::parse("l").is_ok());
|
| 791 |
+
assert!(BadgePosition::parse("r").is_ok());
|
| 792 |
+
assert!(BadgePosition::parse("tl").is_ok());
|
| 793 |
+
assert!(BadgePosition::parse("tr").is_ok());
|
| 794 |
+
assert!(BadgePosition::parse("bl").is_ok());
|
| 795 |
+
assert!(BadgePosition::parse("br").is_ok());
|
| 796 |
}
|
| 797 |
|
| 798 |
#[test]
|
| 799 |
fn validate_poster_position_rejects_invalid() {
|
| 800 |
+
assert!(BadgePosition::parse("center").is_err());
|
| 801 |
+
assert!(BadgePosition::parse("").is_err());
|
| 802 |
+
assert!(BadgePosition::parse("bottom-center").is_err());
|
| 803 |
+
assert!(BadgePosition::parse("middle").is_err());
|
| 804 |
}
|
| 805 |
|
| 806 |
#[test]
|
| 807 |
fn default_poster_position_returns_bottom_center() {
|
| 808 |
+
assert_eq!(default_poster_position(), BadgePosition::BottomCenter);
|
| 809 |
}
|
| 810 |
|
| 811 |
#[test]
|
|
|
|
| 881 |
|
| 882 |
#[test]
|
| 883 |
fn resolve_badge_direction_default_center_positions() {
|
| 884 |
+
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(BadgePosition::parse("bc").unwrap()), BadgeDirection::Horizontal);
|
| 885 |
+
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(BadgePosition::parse("tc").unwrap()), BadgeDirection::Horizontal);
|
| 886 |
}
|
| 887 |
|
| 888 |
#[test]
|
| 889 |
fn resolve_badge_direction_default_side_positions() {
|
| 890 |
+
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(BadgePosition::parse("l").unwrap()), BadgeDirection::Vertical);
|
| 891 |
+
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(BadgePosition::parse("r").unwrap()), BadgeDirection::Vertical);
|
| 892 |
}
|
| 893 |
|
| 894 |
#[test]
|
| 895 |
fn resolve_badge_direction_default_corner_positions() {
|
| 896 |
+
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(BadgePosition::parse("tl").unwrap()), BadgeDirection::Vertical);
|
| 897 |
+
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(BadgePosition::parse("tr").unwrap()), BadgeDirection::Vertical);
|
| 898 |
+
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(BadgePosition::parse("bl").unwrap()), BadgeDirection::Vertical);
|
| 899 |
+
assert_eq!(BadgeDirection::parse("d").unwrap().resolve(BadgePosition::parse("br").unwrap()), BadgeDirection::Vertical);
|
| 900 |
}
|
| 901 |
|
| 902 |
#[test]
|
| 903 |
fn resolve_badge_direction_explicit_passes_through() {
|
| 904 |
+
assert_eq!(BadgeDirection::parse("h").unwrap().resolve(BadgePosition::parse("l").unwrap()), BadgeDirection::Horizontal);
|
| 905 |
+
assert_eq!(BadgeDirection::parse("v").unwrap().resolve(BadgePosition::parse("bc").unwrap()), BadgeDirection::Vertical);
|
| 906 |
}
|
| 907 |
|
| 908 |
// --- ImageSize tests ---
|
|
|
|
| 1009 |
assert!(validate_image_size("huge", crate::cache::ImageType::Poster).is_err());
|
| 1010 |
assert!(validate_image_size("", crate::cache::ImageType::Backdrop).is_err());
|
| 1011 |
}
|
| 1012 |
+
|
| 1013 |
+
// --- Enum round-trip serialization/deserialization tests ---
|
| 1014 |
+
|
| 1015 |
+
#[test]
|
| 1016 |
+
fn badge_style_round_trip() {
|
| 1017 |
+
for variant in [BadgeStyle::Horizontal, BadgeStyle::Vertical, BadgeStyle::Default] {
|
| 1018 |
+
let s = variant.as_str();
|
| 1019 |
+
let parsed = BadgeStyle::parse(s).unwrap();
|
| 1020 |
+
assert_eq!(parsed, variant, "round-trip failed for {s}");
|
| 1021 |
+
// Serde round-trip
|
| 1022 |
+
let json = serde_json::to_string(&variant).unwrap();
|
| 1023 |
+
let deser: BadgeStyle = serde_json::from_str(&json).unwrap();
|
| 1024 |
+
assert_eq!(deser, variant);
|
| 1025 |
+
}
|
| 1026 |
+
}
|
| 1027 |
+
|
| 1028 |
+
#[test]
|
| 1029 |
+
fn badge_direction_round_trip() {
|
| 1030 |
+
for variant in [BadgeDirection::Horizontal, BadgeDirection::Vertical, BadgeDirection::Default] {
|
| 1031 |
+
let s = variant.as_str();
|
| 1032 |
+
let parsed = BadgeDirection::parse(s).unwrap();
|
| 1033 |
+
assert_eq!(parsed, variant);
|
| 1034 |
+
let json = serde_json::to_string(&variant).unwrap();
|
| 1035 |
+
let deser: BadgeDirection = serde_json::from_str(&json).unwrap();
|
| 1036 |
+
assert_eq!(deser, variant);
|
| 1037 |
+
}
|
| 1038 |
+
}
|
| 1039 |
+
|
| 1040 |
+
#[test]
|
| 1041 |
+
fn label_style_round_trip() {
|
| 1042 |
+
for variant in [LabelStyle::Icon, LabelStyle::Text, LabelStyle::Official] {
|
| 1043 |
+
let s = variant.as_str();
|
| 1044 |
+
let parsed = LabelStyle::parse(s).unwrap();
|
| 1045 |
+
assert_eq!(parsed, variant);
|
| 1046 |
+
let json = serde_json::to_string(&variant).unwrap();
|
| 1047 |
+
let deser: LabelStyle = serde_json::from_str(&json).unwrap();
|
| 1048 |
+
assert_eq!(deser, variant);
|
| 1049 |
+
}
|
| 1050 |
+
}
|
| 1051 |
+
|
| 1052 |
+
#[test]
|
| 1053 |
+
fn poster_source_round_trip() {
|
| 1054 |
+
for variant in [PosterSource::Tmdb, PosterSource::Fanart] {
|
| 1055 |
+
let s = variant.as_str();
|
| 1056 |
+
let parsed = PosterSource::parse(s).unwrap();
|
| 1057 |
+
assert_eq!(parsed, variant);
|
| 1058 |
+
let json = serde_json::to_string(&variant).unwrap();
|
| 1059 |
+
let deser: PosterSource = serde_json::from_str(&json).unwrap();
|
| 1060 |
+
assert_eq!(deser, variant);
|
| 1061 |
+
}
|
| 1062 |
+
}
|
| 1063 |
+
|
| 1064 |
+
#[test]
|
| 1065 |
+
fn badge_position_round_trip() {
|
| 1066 |
+
let all = [
|
| 1067 |
+
BadgePosition::BottomCenter, BadgePosition::TopCenter,
|
| 1068 |
+
BadgePosition::Left, BadgePosition::Right,
|
| 1069 |
+
BadgePosition::TopLeft, BadgePosition::TopRight,
|
| 1070 |
+
BadgePosition::BottomLeft, BadgePosition::BottomRight,
|
| 1071 |
+
];
|
| 1072 |
+
for variant in all {
|
| 1073 |
+
let s = variant.as_str();
|
| 1074 |
+
let parsed = BadgePosition::parse(s).unwrap();
|
| 1075 |
+
assert_eq!(parsed, variant, "round-trip failed for {s}");
|
| 1076 |
+
let json = serde_json::to_string(&variant).unwrap();
|
| 1077 |
+
let deser: BadgePosition = serde_json::from_str(&json).unwrap();
|
| 1078 |
+
assert_eq!(deser, variant);
|
| 1079 |
+
}
|
| 1080 |
+
}
|
| 1081 |
+
|
| 1082 |
+
#[test]
|
| 1083 |
+
fn badge_size_round_trip() {
|
| 1084 |
+
let all = [
|
| 1085 |
+
BadgeSize::ExtraSmall, BadgeSize::Small, BadgeSize::Medium,
|
| 1086 |
+
BadgeSize::Large, BadgeSize::ExtraLarge,
|
| 1087 |
+
];
|
| 1088 |
+
for variant in all {
|
| 1089 |
+
let s = variant.as_str();
|
| 1090 |
+
let parsed = BadgeSize::parse(s).unwrap();
|
| 1091 |
+
assert_eq!(parsed, variant, "round-trip failed for {s}");
|
| 1092 |
+
let json = serde_json::to_string(&variant).unwrap();
|
| 1093 |
+
let deser: BadgeSize = serde_json::from_str(&json).unwrap();
|
| 1094 |
+
assert_eq!(deser, variant);
|
| 1095 |
+
// Verify scale_factor and cache_suffix don't panic
|
| 1096 |
+
let _ = variant.scale_factor();
|
| 1097 |
+
let _ = variant.cache_suffix();
|
| 1098 |
+
}
|
| 1099 |
+
}
|
| 1100 |
+
|
| 1101 |
+
#[test]
|
| 1102 |
+
fn badge_style_display_matches_as_str() {
|
| 1103 |
+
assert_eq!(format!("{}", BadgeStyle::Horizontal), "h");
|
| 1104 |
+
assert_eq!(format!("{}", BadgeStyle::Vertical), "v");
|
| 1105 |
+
assert_eq!(format!("{}", BadgeStyle::Default), "d");
|
| 1106 |
+
}
|
| 1107 |
+
|
| 1108 |
+
#[test]
|
| 1109 |
+
fn badge_position_helper_methods() {
|
| 1110 |
+
assert!(BadgePosition::TopCenter.is_top());
|
| 1111 |
+
assert!(BadgePosition::TopLeft.is_top());
|
| 1112 |
+
assert!(BadgePosition::TopRight.is_top());
|
| 1113 |
+
assert!(!BadgePosition::BottomCenter.is_top());
|
| 1114 |
+
|
| 1115 |
+
assert!(BadgePosition::BottomCenter.is_bottom());
|
| 1116 |
+
assert!(BadgePosition::BottomLeft.is_bottom());
|
| 1117 |
+
assert!(BadgePosition::BottomRight.is_bottom());
|
| 1118 |
+
assert!(!BadgePosition::TopCenter.is_bottom());
|
| 1119 |
+
|
| 1120 |
+
assert!(BadgePosition::Left.is_left());
|
| 1121 |
+
assert!(BadgePosition::TopLeft.is_left());
|
| 1122 |
+
assert!(BadgePosition::BottomLeft.is_left());
|
| 1123 |
+
assert!(!BadgePosition::Right.is_left());
|
| 1124 |
+
|
| 1125 |
+
assert!(BadgePosition::Right.is_right());
|
| 1126 |
+
assert!(BadgePosition::TopRight.is_right());
|
| 1127 |
+
assert!(BadgePosition::BottomRight.is_right());
|
| 1128 |
+
assert!(!BadgePosition::Left.is_right());
|
| 1129 |
+
}
|
| 1130 |
+
|
| 1131 |
+
#[test]
|
| 1132 |
+
fn label_style_uses_icon() {
|
| 1133 |
+
assert!(LabelStyle::Icon.uses_icon());
|
| 1134 |
+
assert!(LabelStyle::Official.uses_icon());
|
| 1135 |
+
assert!(!LabelStyle::Text.uses_icon());
|
| 1136 |
+
}
|
| 1137 |
+
|
| 1138 |
+
#[test]
|
| 1139 |
+
fn poster_source_is_fanart() {
|
| 1140 |
+
assert!(PosterSource::Fanart.is_fanart());
|
| 1141 |
+
assert!(!PosterSource::Tmdb.is_fanart());
|
| 1142 |
+
}
|
| 1143 |
+
|
| 1144 |
+
#[test]
|
| 1145 |
+
fn badge_size_scale_factors_ordered() {
|
| 1146 |
+
let xs = BadgeSize::ExtraSmall.scale_factor();
|
| 1147 |
+
let s = BadgeSize::Small.scale_factor();
|
| 1148 |
+
let m = BadgeSize::Medium.scale_factor();
|
| 1149 |
+
let l = BadgeSize::Large.scale_factor();
|
| 1150 |
+
let xl = BadgeSize::ExtraLarge.scale_factor();
|
| 1151 |
+
assert!(xs < s);
|
| 1152 |
+
assert!(s < m);
|
| 1153 |
+
assert!(m < l);
|
| 1154 |
+
assert!(l < xl);
|
| 1155 |
+
}
|
| 1156 |
+
|
| 1157 |
+
#[test]
|
| 1158 |
+
fn parse_global_render_settings_with_all_enum_fields() {
|
| 1159 |
+
let mut globals = HashMap::new();
|
| 1160 |
+
globals.insert("poster_source".into(), "f".into());
|
| 1161 |
+
globals.insert("poster_position".into(), "tl".into());
|
| 1162 |
+
globals.insert("poster_badge_style".into(), "v".into());
|
| 1163 |
+
globals.insert("logo_badge_style".into(), "h".into());
|
| 1164 |
+
globals.insert("backdrop_badge_style".into(), "h".into());
|
| 1165 |
+
globals.insert("poster_label_style".into(), "t".into());
|
| 1166 |
+
globals.insert("logo_label_style".into(), "i".into());
|
| 1167 |
+
globals.insert("backdrop_label_style".into(), "o".into());
|
| 1168 |
+
globals.insert("poster_badge_direction".into(), "h".into());
|
| 1169 |
+
globals.insert("poster_badge_size".into(), "xl".into());
|
| 1170 |
+
globals.insert("logo_badge_size".into(), "xs".into());
|
| 1171 |
+
globals.insert("backdrop_badge_size".into(), "l".into());
|
| 1172 |
+
|
| 1173 |
+
let settings = parse_global_render_settings(&globals);
|
| 1174 |
+
assert_eq!(settings.poster_source, PosterSource::Fanart);
|
| 1175 |
+
assert_eq!(settings.poster_position, BadgePosition::TopLeft);
|
| 1176 |
+
assert_eq!(settings.poster_badge_style, BadgeStyle::Vertical);
|
| 1177 |
+
assert_eq!(settings.logo_badge_style, BadgeStyle::Horizontal);
|
| 1178 |
+
assert_eq!(settings.backdrop_badge_style, BadgeStyle::Horizontal);
|
| 1179 |
+
assert_eq!(settings.poster_label_style, LabelStyle::Text);
|
| 1180 |
+
assert_eq!(settings.logo_label_style, LabelStyle::Icon);
|
| 1181 |
+
assert_eq!(settings.backdrop_label_style, LabelStyle::Official);
|
| 1182 |
+
assert_eq!(settings.poster_badge_direction, BadgeDirection::Horizontal);
|
| 1183 |
+
assert_eq!(settings.poster_badge_size, BadgeSize::ExtraLarge);
|
| 1184 |
+
assert_eq!(settings.logo_badge_size, BadgeSize::ExtraSmall);
|
| 1185 |
+
assert_eq!(settings.backdrop_badge_size, BadgeSize::Large);
|
| 1186 |
+
}
|
| 1187 |
+
|
| 1188 |
+
#[test]
|
| 1189 |
+
fn parse_global_render_settings_invalid_values_use_defaults() {
|
| 1190 |
+
let mut globals = HashMap::new();
|
| 1191 |
+
globals.insert("poster_badge_style".into(), "invalid".into());
|
| 1192 |
+
globals.insert("poster_position".into(), "nowhere".into());
|
| 1193 |
+
globals.insert("poster_badge_size".into(), "gigantic".into());
|
| 1194 |
+
|
| 1195 |
+
let settings = parse_global_render_settings(&globals);
|
| 1196 |
+
// Invalid values should fall back to defaults
|
| 1197 |
+
assert_eq!(settings.poster_badge_style, BadgeStyle::Default);
|
| 1198 |
+
assert_eq!(settings.poster_position, BadgePosition::BottomCenter);
|
| 1199 |
+
assert_eq!(settings.poster_badge_size, BadgeSize::Medium);
|
| 1200 |
+
}
|
| 1201 |
+
|
| 1202 |
+
#[test]
|
| 1203 |
+
fn render_settings_default_values() {
|
| 1204 |
+
let defaults = RenderSettings::default();
|
| 1205 |
+
assert_eq!(defaults.poster_source, PosterSource::Tmdb);
|
| 1206 |
+
assert_eq!(defaults.poster_position, BadgePosition::BottomCenter);
|
| 1207 |
+
assert_eq!(defaults.poster_badge_style, BadgeStyle::Default);
|
| 1208 |
+
assert_eq!(defaults.logo_badge_style, BadgeStyle::Vertical);
|
| 1209 |
+
assert_eq!(defaults.backdrop_badge_style, BadgeStyle::Vertical);
|
| 1210 |
+
assert_eq!(defaults.poster_label_style, LabelStyle::Official);
|
| 1211 |
+
assert_eq!(defaults.poster_badge_direction, BadgeDirection::Default);
|
| 1212 |
+
assert_eq!(defaults.poster_badge_size, BadgeSize::Medium);
|
| 1213 |
+
assert_eq!(defaults.logo_badge_size, BadgeSize::Medium);
|
| 1214 |
+
assert_eq!(defaults.backdrop_badge_size, BadgeSize::Medium);
|
| 1215 |
+
assert!(defaults.is_default);
|
| 1216 |
+
assert!(!defaults.fanart_override);
|
| 1217 |
+
}
|
| 1218 |
}
|
| 1219 |
|
| 1220 |
// --- Admin user CRUD ---
|
|
|
|
| 1673 |
pub ratings_limit: i32,
|
| 1674 |
pub ratings_order: Arc<str>,
|
| 1675 |
pub is_default: bool,
|
| 1676 |
+
pub poster_position: BadgePosition,
|
| 1677 |
pub logo_ratings_limit: i32,
|
| 1678 |
pub backdrop_ratings_limit: i32,
|
| 1679 |
pub poster_badge_style: BadgeStyle,
|
|
|
|
| 1686 |
pub poster_badge_size: BadgeSize,
|
| 1687 |
pub logo_badge_size: BadgeSize,
|
| 1688 |
pub backdrop_badge_size: BadgeSize,
|
| 1689 |
+
/// Set when a query param override (e.g. `?lang=`, `?fanart_textless=true`) forces the fanart code path at request time.
|
| 1690 |
#[serde(skip)]
|
| 1691 |
+
pub fanart_override: bool,
|
| 1692 |
}
|
| 1693 |
|
| 1694 |
impl Default for RenderSettings {
|
|
|
|
| 1700 |
ratings_limit: default_ratings_limit(),
|
| 1701 |
ratings_order: Arc::from("mal,imdb,lb,rt,mc,rta,tmdb,trakt"),
|
| 1702 |
is_default: true,
|
| 1703 |
+
poster_position: BadgePosition::BottomCenter,
|
| 1704 |
logo_ratings_limit: default_logo_backdrop_ratings_limit(),
|
| 1705 |
backdrop_ratings_limit: default_logo_backdrop_ratings_limit(),
|
| 1706 |
poster_badge_style: BadgeStyle::Default,
|
|
|
|
| 1713 |
poster_badge_size: BadgeSize::Medium,
|
| 1714 |
logo_badge_size: BadgeSize::Medium,
|
| 1715 |
backdrop_badge_size: BadgeSize::Medium,
|
| 1716 |
+
fanart_override: false,
|
| 1717 |
}
|
| 1718 |
}
|
| 1719 |
}
|
|
|
|
| 1744 |
.unwrap_or(defaults.ratings_limit),
|
| 1745 |
ratings_order: arc_or("ratings_order", defaults.ratings_order),
|
| 1746 |
is_default: true,
|
| 1747 |
+
poster_position: global_or(globals, "poster_position", BadgePosition::parse, defaults.poster_position),
|
| 1748 |
logo_ratings_limit: globals
|
| 1749 |
.get("logo_ratings_limit")
|
| 1750 |
.and_then(|v| v.parse().ok())
|
|
|
|
| 1763 |
poster_badge_size: global_or(globals, "poster_badge_size", BadgeSize::parse, defaults.poster_badge_size),
|
| 1764 |
logo_badge_size: global_or(globals, "logo_badge_size", BadgeSize::parse, defaults.logo_badge_size),
|
| 1765 |
backdrop_badge_size: global_or(globals, "backdrop_badge_size", BadgeSize::parse, defaults.backdrop_badge_size),
|
| 1766 |
+
fanart_override: false,
|
| 1767 |
}
|
| 1768 |
}
|
| 1769 |
|
|
|
|
| 1782 |
ratings_limit: s.ratings_limit,
|
| 1783 |
ratings_order: Arc::from(s.ratings_order.as_str()),
|
| 1784 |
is_default: false,
|
| 1785 |
+
poster_position: parse_setting_or_default(&s.poster_position, "poster_position", BadgePosition::parse, BadgePosition::BottomCenter),
|
| 1786 |
logo_ratings_limit: s.logo_ratings_limit,
|
| 1787 |
backdrop_ratings_limit: s.backdrop_ratings_limit,
|
| 1788 |
poster_badge_style: parse_setting_or_default(&s.poster_badge_style, "poster_badge_style", BadgeStyle::parse, BadgeStyle::Default),
|
|
|
|
| 1795 |
poster_badge_size: parse_setting_or_default(&s.poster_badge_size, "poster_badge_size", BadgeSize::parse, BadgeSize::Medium),
|
| 1796 |
logo_badge_size: parse_setting_or_default(&s.logo_badge_size, "logo_badge_size", BadgeSize::parse, BadgeSize::Medium),
|
| 1797 |
backdrop_badge_size: parse_setting_or_default(&s.backdrop_badge_size, "backdrop_badge_size", BadgeSize::parse, BadgeSize::Medium),
|
| 1798 |
+
fanart_override: false,
|
| 1799 |
};
|
| 1800 |
}
|
| 1801 |
Ok(None) => {} // no per-key override, fall through
|
api/tests/db_operations.rs
CHANGED
|
@@ -752,7 +752,7 @@ async fn effective_settings_include_new_fields() {
|
|
| 752 |
|
| 753 |
// Without per-key settings, effective should have defaults
|
| 754 |
let s = db::get_effective_render_settings(&state.db, key_id, None).await;
|
| 755 |
-
assert_eq!(s.poster_position, db::
|
| 756 |
assert_eq!(s.logo_ratings_limit, 5);
|
| 757 |
assert_eq!(s.backdrop_ratings_limit, 5);
|
| 758 |
|
|
@@ -765,7 +765,7 @@ async fn effective_settings_include_new_fields() {
|
|
| 765 |
}).await.unwrap();
|
| 766 |
|
| 767 |
let s = db::get_effective_render_settings(&state.db, key_id, None).await;
|
| 768 |
-
assert_eq!(s.poster_position, db::
|
| 769 |
assert_eq!(s.logo_ratings_limit, 2);
|
| 770 |
assert_eq!(s.backdrop_ratings_limit, 0);
|
| 771 |
}
|
|
|
|
| 752 |
|
| 753 |
// Without per-key settings, effective should have defaults
|
| 754 |
let s = db::get_effective_render_settings(&state.db, key_id, None).await;
|
| 755 |
+
assert_eq!(s.poster_position, db::BadgePosition::BottomCenter);
|
| 756 |
assert_eq!(s.logo_ratings_limit, 5);
|
| 757 |
assert_eq!(s.backdrop_ratings_limit, 5);
|
| 758 |
|
|
|
|
| 765 |
}).await.unwrap();
|
| 766 |
|
| 767 |
let s = db::get_effective_render_settings(&state.db, key_id, None).await;
|
| 768 |
+
assert_eq!(s.poster_position, db::BadgePosition::Right);
|
| 769 |
assert_eq!(s.logo_ratings_limit, 2);
|
| 770 |
assert_eq!(s.backdrop_ratings_limit, 0);
|
| 771 |
}
|
api/tests/e2e_settings.rs
ADDED
|
@@ -0,0 +1,514 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
mod common;
|
| 2 |
+
|
| 3 |
+
use axum::body::Body;
|
| 4 |
+
use axum::http::{Request, StatusCode};
|
| 5 |
+
use http_body_util::BodyExt;
|
| 6 |
+
use serde_json::{json, Value};
|
| 7 |
+
use tower::ServiceExt;
|
| 8 |
+
|
| 9 |
+
fn authed_request(method: &str, uri: &str, token: &str, body: Option<Value>) -> Request<Body> {
|
| 10 |
+
let mut builder = Request::builder()
|
| 11 |
+
.method(method)
|
| 12 |
+
.uri(uri)
|
| 13 |
+
.header("authorization", format!("Bearer {token}"))
|
| 14 |
+
.header("content-type", "application/json");
|
| 15 |
+
match body {
|
| 16 |
+
Some(b) => builder.body(Body::from(b.to_string())).unwrap(),
|
| 17 |
+
None => builder.body(Body::empty()).unwrap(),
|
| 18 |
+
}
|
| 19 |
+
}
|
| 20 |
+
|
| 21 |
+
async fn parse_json(res: axum::http::Response<Body>) -> Value {
|
| 22 |
+
let body = res.into_body().collect().await.unwrap().to_bytes();
|
| 23 |
+
serde_json::from_slice(&body).unwrap()
|
| 24 |
+
}
|
| 25 |
+
|
| 26 |
+
async fn create_api_key(app: &axum::Router, token: &str) -> (i32, String) {
|
| 27 |
+
let req = authed_request("POST", "/api/keys", token, Some(json!({"name":"e2e-test"})));
|
| 28 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 29 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 30 |
+
let json = parse_json(res).await;
|
| 31 |
+
(json["id"].as_i64().unwrap() as i32, json["key"].as_str().unwrap().to_string())
|
| 32 |
+
}
|
| 33 |
+
|
| 34 |
+
// --- Global settings round-trip ---
|
| 35 |
+
|
| 36 |
+
#[tokio::test]
|
| 37 |
+
async fn global_settings_round_trip_all_fields() {
|
| 38 |
+
let (app, _state) = common::setup_test_app().await;
|
| 39 |
+
let token = common::setup_admin(&app).await;
|
| 40 |
+
|
| 41 |
+
// Update global settings with non-default values
|
| 42 |
+
let update = json!({
|
| 43 |
+
"poster_source": "f",
|
| 44 |
+
"fanart_lang": "de",
|
| 45 |
+
"fanart_textless": true,
|
| 46 |
+
"ratings_limit": 5,
|
| 47 |
+
"ratings_order": "imdb,rt,mc,tmdb,trakt,mal,lb,rta",
|
| 48 |
+
"poster_position": "tl",
|
| 49 |
+
"logo_ratings_limit": 2,
|
| 50 |
+
"backdrop_ratings_limit": 7,
|
| 51 |
+
"poster_badge_style": "v",
|
| 52 |
+
"logo_badge_style": "h",
|
| 53 |
+
"backdrop_badge_style": "h",
|
| 54 |
+
"poster_label_style": "t",
|
| 55 |
+
"logo_label_style": "i",
|
| 56 |
+
"backdrop_label_style": "o",
|
| 57 |
+
"poster_badge_direction": "h",
|
| 58 |
+
"poster_badge_size": "xl",
|
| 59 |
+
"logo_badge_size": "xs",
|
| 60 |
+
"backdrop_badge_size": "l",
|
| 61 |
+
});
|
| 62 |
+
let req = authed_request("PUT", "/api/admin/settings", &token, Some(update.clone()));
|
| 63 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 64 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 65 |
+
|
| 66 |
+
// Read them back
|
| 67 |
+
let req = authed_request("GET", "/api/admin/settings", &token, None);
|
| 68 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 69 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 70 |
+
let settings = parse_json(res).await;
|
| 71 |
+
|
| 72 |
+
assert_eq!(settings["poster_source"], "f");
|
| 73 |
+
assert_eq!(settings["fanart_lang"], "de");
|
| 74 |
+
assert_eq!(settings["fanart_textless"], true);
|
| 75 |
+
assert_eq!(settings["ratings_limit"], 5);
|
| 76 |
+
assert_eq!(settings["ratings_order"], "imdb,rt,mc,tmdb,trakt,mal,lb,rta");
|
| 77 |
+
assert_eq!(settings["poster_position"], "tl");
|
| 78 |
+
assert_eq!(settings["logo_ratings_limit"], 2);
|
| 79 |
+
assert_eq!(settings["backdrop_ratings_limit"], 7);
|
| 80 |
+
assert_eq!(settings["poster_badge_style"], "v");
|
| 81 |
+
assert_eq!(settings["logo_badge_style"], "h");
|
| 82 |
+
assert_eq!(settings["backdrop_badge_style"], "h");
|
| 83 |
+
assert_eq!(settings["poster_label_style"], "t");
|
| 84 |
+
assert_eq!(settings["logo_label_style"], "i");
|
| 85 |
+
assert_eq!(settings["backdrop_label_style"], "o");
|
| 86 |
+
assert_eq!(settings["poster_badge_direction"], "h");
|
| 87 |
+
assert_eq!(settings["poster_badge_size"], "xl");
|
| 88 |
+
assert_eq!(settings["logo_badge_size"], "xs");
|
| 89 |
+
assert_eq!(settings["backdrop_badge_size"], "l");
|
| 90 |
+
}
|
| 91 |
+
|
| 92 |
+
// --- Per-key settings round-trip ---
|
| 93 |
+
|
| 94 |
+
#[tokio::test]
|
| 95 |
+
async fn per_key_settings_round_trip() {
|
| 96 |
+
let (app, _state) = common::setup_test_app().await;
|
| 97 |
+
let token = common::setup_admin(&app).await;
|
| 98 |
+
let (key_id, _raw_key) = create_api_key(&app, &token).await;
|
| 99 |
+
|
| 100 |
+
// Read defaults (should be global/default)
|
| 101 |
+
let req = authed_request("GET", &format!("/api/keys/{key_id}/settings"), &token, None);
|
| 102 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 103 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 104 |
+
let defaults = parse_json(res).await;
|
| 105 |
+
assert_eq!(defaults["is_default"], true);
|
| 106 |
+
assert_eq!(defaults["poster_badge_size"], "m");
|
| 107 |
+
|
| 108 |
+
// Set per-key overrides
|
| 109 |
+
let update = json!({
|
| 110 |
+
"poster_source": "t",
|
| 111 |
+
"ratings_limit": 1,
|
| 112 |
+
"ratings_order": "tmdb",
|
| 113 |
+
"poster_position": "r",
|
| 114 |
+
"logo_ratings_limit": 4,
|
| 115 |
+
"backdrop_ratings_limit": 6,
|
| 116 |
+
"poster_badge_style": "h",
|
| 117 |
+
"logo_badge_style": "v",
|
| 118 |
+
"backdrop_badge_style": "v",
|
| 119 |
+
"poster_label_style": "o",
|
| 120 |
+
"logo_label_style": "o",
|
| 121 |
+
"backdrop_label_style": "t",
|
| 122 |
+
"poster_badge_direction": "v",
|
| 123 |
+
"poster_badge_size": "s",
|
| 124 |
+
"logo_badge_size": "l",
|
| 125 |
+
"backdrop_badge_size": "xl",
|
| 126 |
+
});
|
| 127 |
+
let req = authed_request("PUT", &format!("/api/keys/{key_id}/settings"), &token, Some(update));
|
| 128 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 129 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 130 |
+
|
| 131 |
+
// Read back — should reflect per-key values
|
| 132 |
+
let req = authed_request("GET", &format!("/api/keys/{key_id}/settings"), &token, None);
|
| 133 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 134 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 135 |
+
let settings = parse_json(res).await;
|
| 136 |
+
|
| 137 |
+
assert_eq!(settings["is_default"], false);
|
| 138 |
+
assert_eq!(settings["ratings_limit"], 1);
|
| 139 |
+
assert_eq!(settings["poster_position"], "r");
|
| 140 |
+
assert_eq!(settings["poster_badge_style"], "h");
|
| 141 |
+
assert_eq!(settings["logo_badge_style"], "v");
|
| 142 |
+
assert_eq!(settings["poster_label_style"], "o");
|
| 143 |
+
assert_eq!(settings["poster_badge_direction"], "v");
|
| 144 |
+
assert_eq!(settings["poster_badge_size"], "s");
|
| 145 |
+
assert_eq!(settings["logo_badge_size"], "l");
|
| 146 |
+
assert_eq!(settings["backdrop_badge_size"], "xl");
|
| 147 |
+
assert_eq!(settings["logo_ratings_limit"], 4);
|
| 148 |
+
assert_eq!(settings["backdrop_ratings_limit"], 6);
|
| 149 |
+
}
|
| 150 |
+
|
| 151 |
+
// --- Per-key reset falls back to global ---
|
| 152 |
+
|
| 153 |
+
#[tokio::test]
|
| 154 |
+
async fn per_key_reset_falls_back_to_global() {
|
| 155 |
+
let (app, _state) = common::setup_test_app().await;
|
| 156 |
+
let token = common::setup_admin(&app).await;
|
| 157 |
+
let (key_id, _raw_key) = create_api_key(&app, &token).await;
|
| 158 |
+
|
| 159 |
+
// Set global to something non-default
|
| 160 |
+
let global = json!({
|
| 161 |
+
"poster_source": "f",
|
| 162 |
+
"ratings_limit": 7,
|
| 163 |
+
"ratings_order": "rt,imdb",
|
| 164 |
+
"poster_position": "bl",
|
| 165 |
+
"poster_badge_style": "v",
|
| 166 |
+
});
|
| 167 |
+
let req = authed_request("PUT", "/api/admin/settings", &token, Some(global));
|
| 168 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 169 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 170 |
+
|
| 171 |
+
// Set per-key override
|
| 172 |
+
let per_key = json!({
|
| 173 |
+
"poster_source": "t",
|
| 174 |
+
"ratings_limit": 2,
|
| 175 |
+
"ratings_order": "tmdb",
|
| 176 |
+
"poster_badge_style": "h",
|
| 177 |
+
});
|
| 178 |
+
let req = authed_request("PUT", &format!("/api/keys/{key_id}/settings"), &token, Some(per_key));
|
| 179 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 180 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 181 |
+
|
| 182 |
+
// Delete per-key settings
|
| 183 |
+
let req = authed_request("DELETE", &format!("/api/keys/{key_id}/settings"), &token, None);
|
| 184 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 185 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 186 |
+
|
| 187 |
+
// Invalidate settings cache to force fresh load
|
| 188 |
+
_state.settings_cache.invalidate(&key_id).await;
|
| 189 |
+
|
| 190 |
+
// Read back — should reflect global values
|
| 191 |
+
let req = authed_request("GET", &format!("/api/keys/{key_id}/settings"), &token, None);
|
| 192 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 193 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 194 |
+
let settings = parse_json(res).await;
|
| 195 |
+
|
| 196 |
+
assert_eq!(settings["is_default"], true);
|
| 197 |
+
assert_eq!(settings["poster_source"], "f");
|
| 198 |
+
assert_eq!(settings["ratings_limit"], 7);
|
| 199 |
+
assert_eq!(settings["poster_position"], "bl");
|
| 200 |
+
assert_eq!(settings["poster_badge_style"], "v");
|
| 201 |
+
}
|
| 202 |
+
|
| 203 |
+
// --- Self-service settings round-trip ---
|
| 204 |
+
|
| 205 |
+
#[tokio::test]
|
| 206 |
+
async fn self_service_settings_round_trip() {
|
| 207 |
+
let (app, _state) = common::setup_test_app().await;
|
| 208 |
+
let api_key_token = common::setup_api_key_session(&app).await;
|
| 209 |
+
|
| 210 |
+
// Read defaults
|
| 211 |
+
let req = Request::builder()
|
| 212 |
+
.uri("/api/key/me/settings")
|
| 213 |
+
.header("authorization", format!("Bearer {api_key_token}"))
|
| 214 |
+
.body(Body::empty())
|
| 215 |
+
.unwrap();
|
| 216 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 217 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 218 |
+
let defaults = parse_json(res).await;
|
| 219 |
+
assert_eq!(defaults["is_default"], true);
|
| 220 |
+
|
| 221 |
+
// Update own settings
|
| 222 |
+
let update = json!({
|
| 223 |
+
"poster_source": "t",
|
| 224 |
+
"ratings_limit": 4,
|
| 225 |
+
"ratings_order": "imdb,tmdb,rt,mc",
|
| 226 |
+
"poster_position": "tc",
|
| 227 |
+
"poster_badge_style": "h",
|
| 228 |
+
"logo_badge_style": "h",
|
| 229 |
+
"backdrop_badge_style": "h",
|
| 230 |
+
"poster_label_style": "t",
|
| 231 |
+
"logo_label_style": "t",
|
| 232 |
+
"backdrop_label_style": "t",
|
| 233 |
+
"poster_badge_direction": "h",
|
| 234 |
+
"poster_badge_size": "l",
|
| 235 |
+
"logo_badge_size": "s",
|
| 236 |
+
"backdrop_badge_size": "xs",
|
| 237 |
+
});
|
| 238 |
+
let req = Request::builder()
|
| 239 |
+
.method("PUT")
|
| 240 |
+
.uri("/api/key/me/settings")
|
| 241 |
+
.header("authorization", format!("Bearer {api_key_token}"))
|
| 242 |
+
.header("content-type", "application/json")
|
| 243 |
+
.body(Body::from(update.to_string()))
|
| 244 |
+
.unwrap();
|
| 245 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 246 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 247 |
+
|
| 248 |
+
// Read back
|
| 249 |
+
let req = Request::builder()
|
| 250 |
+
.uri("/api/key/me/settings")
|
| 251 |
+
.header("authorization", format!("Bearer {api_key_token}"))
|
| 252 |
+
.body(Body::empty())
|
| 253 |
+
.unwrap();
|
| 254 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 255 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 256 |
+
let settings = parse_json(res).await;
|
| 257 |
+
|
| 258 |
+
assert_eq!(settings["is_default"], false);
|
| 259 |
+
assert_eq!(settings["ratings_limit"], 4);
|
| 260 |
+
assert_eq!(settings["poster_position"], "tc");
|
| 261 |
+
assert_eq!(settings["poster_badge_style"], "h");
|
| 262 |
+
assert_eq!(settings["poster_badge_direction"], "h");
|
| 263 |
+
assert_eq!(settings["poster_badge_size"], "l");
|
| 264 |
+
assert_eq!(settings["logo_badge_size"], "s");
|
| 265 |
+
assert_eq!(settings["backdrop_badge_size"], "xs");
|
| 266 |
+
|
| 267 |
+
// Reset own settings
|
| 268 |
+
let req = Request::builder()
|
| 269 |
+
.method("DELETE")
|
| 270 |
+
.uri("/api/key/me/settings")
|
| 271 |
+
.header("authorization", format!("Bearer {api_key_token}"))
|
| 272 |
+
.body(Body::empty())
|
| 273 |
+
.unwrap();
|
| 274 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 275 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 276 |
+
|
| 277 |
+
// Invalidate cache
|
| 278 |
+
_state.settings_cache.invalidate_all();
|
| 279 |
+
|
| 280 |
+
// Read back — should be defaults again
|
| 281 |
+
let req = Request::builder()
|
| 282 |
+
.uri("/api/key/me/settings")
|
| 283 |
+
.header("authorization", format!("Bearer {api_key_token}"))
|
| 284 |
+
.body(Body::empty())
|
| 285 |
+
.unwrap();
|
| 286 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 287 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 288 |
+
let settings = parse_json(res).await;
|
| 289 |
+
assert_eq!(settings["is_default"], true);
|
| 290 |
+
}
|
| 291 |
+
|
| 292 |
+
// --- Validation: global settings rejects invalid values ---
|
| 293 |
+
|
| 294 |
+
#[tokio::test]
|
| 295 |
+
async fn global_settings_rejects_invalid_ratings_limit() {
|
| 296 |
+
let (app, _state) = common::setup_test_app().await;
|
| 297 |
+
let token = common::setup_admin(&app).await;
|
| 298 |
+
|
| 299 |
+
let update = json!({
|
| 300 |
+
"poster_source": "t",
|
| 301 |
+
"ratings_limit": 10,
|
| 302 |
+
});
|
| 303 |
+
let req = authed_request("PUT", "/api/admin/settings", &token, Some(update));
|
| 304 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 305 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 306 |
+
}
|
| 307 |
+
|
| 308 |
+
#[tokio::test]
|
| 309 |
+
async fn global_settings_rejects_invalid_fanart_lang() {
|
| 310 |
+
let (app, _state) = common::setup_test_app().await;
|
| 311 |
+
let token = common::setup_admin(&app).await;
|
| 312 |
+
|
| 313 |
+
let update = json!({
|
| 314 |
+
"poster_source": "t",
|
| 315 |
+
"fanart_lang": "x",
|
| 316 |
+
});
|
| 317 |
+
let req = authed_request("PUT", "/api/admin/settings", &token, Some(update));
|
| 318 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 319 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 320 |
+
}
|
| 321 |
+
|
| 322 |
+
#[tokio::test]
|
| 323 |
+
async fn global_settings_rejects_invalid_ratings_order() {
|
| 324 |
+
let (app, _state) = common::setup_test_app().await;
|
| 325 |
+
let token = common::setup_admin(&app).await;
|
| 326 |
+
|
| 327 |
+
let update = json!({
|
| 328 |
+
"poster_source": "t",
|
| 329 |
+
"ratings_order": "bogus",
|
| 330 |
+
});
|
| 331 |
+
let req = authed_request("PUT", "/api/admin/settings", &token, Some(update));
|
| 332 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 333 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 334 |
+
}
|
| 335 |
+
|
| 336 |
+
#[tokio::test]
|
| 337 |
+
async fn global_settings_rejects_invalid_badge_style() {
|
| 338 |
+
let (app, _state) = common::setup_test_app().await;
|
| 339 |
+
let token = common::setup_admin(&app).await;
|
| 340 |
+
|
| 341 |
+
let update = json!({
|
| 342 |
+
"poster_source": "t",
|
| 343 |
+
"poster_badge_style": "z",
|
| 344 |
+
});
|
| 345 |
+
let req = authed_request("PUT", "/api/admin/settings", &token, Some(update));
|
| 346 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 347 |
+
// Invalid enum values fail at deserialization (422) rather than validation (400)
|
| 348 |
+
assert_eq!(res.status(), StatusCode::UNPROCESSABLE_ENTITY);
|
| 349 |
+
}
|
| 350 |
+
|
| 351 |
+
#[tokio::test]
|
| 352 |
+
async fn per_key_settings_rejects_invalid_logo_ratings_limit() {
|
| 353 |
+
let (app, _state) = common::setup_test_app().await;
|
| 354 |
+
let token = common::setup_admin(&app).await;
|
| 355 |
+
let (key_id, _) = create_api_key(&app, &token).await;
|
| 356 |
+
|
| 357 |
+
let update = json!({
|
| 358 |
+
"poster_source": "t",
|
| 359 |
+
"logo_ratings_limit": 9,
|
| 360 |
+
});
|
| 361 |
+
let req = authed_request("PUT", &format!("/api/keys/{key_id}/settings"), &token, Some(update));
|
| 362 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 363 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 364 |
+
}
|
| 365 |
+
|
| 366 |
+
// --- Preview generates different images for different badge styles ---
|
| 367 |
+
|
| 368 |
+
#[tokio::test]
|
| 369 |
+
async fn preview_badge_style_produces_different_images() {
|
| 370 |
+
let (app, _state) = common::setup_test_app().await;
|
| 371 |
+
let token = common::setup_admin(&app).await;
|
| 372 |
+
|
| 373 |
+
let res_h = app.clone().oneshot(
|
| 374 |
+
authed_request("GET", "/api/admin/preview/poster?ratings_limit=3&badge_style=h", &token, None),
|
| 375 |
+
).await.unwrap();
|
| 376 |
+
assert_eq!(res_h.status(), StatusCode::OK);
|
| 377 |
+
let body_h = res_h.into_body().collect().await.unwrap().to_bytes();
|
| 378 |
+
|
| 379 |
+
let res_v = app.clone().oneshot(
|
| 380 |
+
authed_request("GET", "/api/admin/preview/poster?ratings_limit=3&badge_style=v", &token, None),
|
| 381 |
+
).await.unwrap();
|
| 382 |
+
assert_eq!(res_v.status(), StatusCode::OK);
|
| 383 |
+
let body_v = res_v.into_body().collect().await.unwrap().to_bytes();
|
| 384 |
+
|
| 385 |
+
// Both valid JPEGs
|
| 386 |
+
assert_eq!(body_h[0], 0xFF);
|
| 387 |
+
assert_eq!(body_v[0], 0xFF);
|
| 388 |
+
// Different badge styles should produce different images
|
| 389 |
+
assert_ne!(body_h, body_v);
|
| 390 |
+
}
|
| 391 |
+
|
| 392 |
+
#[tokio::test]
|
| 393 |
+
async fn preview_label_style_produces_different_images() {
|
| 394 |
+
let (app, _state) = common::setup_test_app().await;
|
| 395 |
+
let token = common::setup_admin(&app).await;
|
| 396 |
+
|
| 397 |
+
let res_text = app.clone().oneshot(
|
| 398 |
+
authed_request("GET", "/api/admin/preview/poster?ratings_limit=3&label_style=t", &token, None),
|
| 399 |
+
).await.unwrap();
|
| 400 |
+
assert_eq!(res_text.status(), StatusCode::OK);
|
| 401 |
+
let body_text = res_text.into_body().collect().await.unwrap().to_bytes();
|
| 402 |
+
|
| 403 |
+
let res_icon = app.clone().oneshot(
|
| 404 |
+
authed_request("GET", "/api/admin/preview/poster?ratings_limit=3&label_style=i", &token, None),
|
| 405 |
+
).await.unwrap();
|
| 406 |
+
assert_eq!(res_icon.status(), StatusCode::OK);
|
| 407 |
+
let body_icon = res_icon.into_body().collect().await.unwrap().to_bytes();
|
| 408 |
+
|
| 409 |
+
assert_eq!(body_text[0], 0xFF);
|
| 410 |
+
assert_eq!(body_icon[0], 0xFF);
|
| 411 |
+
assert_ne!(body_text, body_icon);
|
| 412 |
+
}
|
| 413 |
+
|
| 414 |
+
#[tokio::test]
|
| 415 |
+
async fn preview_badge_size_produces_different_images() {
|
| 416 |
+
let (app, _state) = common::setup_test_app().await;
|
| 417 |
+
let token = common::setup_admin(&app).await;
|
| 418 |
+
|
| 419 |
+
let res_s = app.clone().oneshot(
|
| 420 |
+
authed_request("GET", "/api/admin/preview/poster?ratings_limit=3&badge_size=xs", &token, None),
|
| 421 |
+
).await.unwrap();
|
| 422 |
+
assert_eq!(res_s.status(), StatusCode::OK);
|
| 423 |
+
let body_s = res_s.into_body().collect().await.unwrap().to_bytes();
|
| 424 |
+
|
| 425 |
+
let res_xl = app.clone().oneshot(
|
| 426 |
+
authed_request("GET", "/api/admin/preview/poster?ratings_limit=3&badge_size=xl", &token, None),
|
| 427 |
+
).await.unwrap();
|
| 428 |
+
assert_eq!(res_xl.status(), StatusCode::OK);
|
| 429 |
+
let body_xl = res_xl.into_body().collect().await.unwrap().to_bytes();
|
| 430 |
+
|
| 431 |
+
assert_eq!(body_s[0], 0xFF);
|
| 432 |
+
assert_eq!(body_xl[0], 0xFF);
|
| 433 |
+
assert_ne!(body_s, body_xl);
|
| 434 |
+
}
|
| 435 |
+
|
| 436 |
+
// --- Logo/Backdrop preview endpoints ---
|
| 437 |
+
|
| 438 |
+
#[tokio::test]
|
| 439 |
+
async fn preview_logo_returns_png() {
|
| 440 |
+
let (app, _state) = common::setup_test_app().await;
|
| 441 |
+
let token = common::setup_admin(&app).await;
|
| 442 |
+
|
| 443 |
+
let res = app.clone().oneshot(
|
| 444 |
+
authed_request("GET", "/api/admin/preview/logo?ratings_limit=2&badge_style=h", &token, None),
|
| 445 |
+
).await.unwrap();
|
| 446 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 447 |
+
assert_eq!(res.headers().get("content-type").unwrap(), "image/png");
|
| 448 |
+
|
| 449 |
+
let body = res.into_body().collect().await.unwrap().to_bytes();
|
| 450 |
+
assert!(&body[..4] == &[0x89, b'P', b'N', b'G'], "should be valid PNG");
|
| 451 |
+
}
|
| 452 |
+
|
| 453 |
+
#[tokio::test]
|
| 454 |
+
async fn preview_backdrop_returns_jpeg() {
|
| 455 |
+
let (app, _state) = common::setup_test_app().await;
|
| 456 |
+
let token = common::setup_admin(&app).await;
|
| 457 |
+
|
| 458 |
+
let res = app.clone().oneshot(
|
| 459 |
+
authed_request("GET", "/api/admin/preview/backdrop?ratings_limit=2&badge_style=v", &token, None),
|
| 460 |
+
).await.unwrap();
|
| 461 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 462 |
+
assert_eq!(res.headers().get("content-type").unwrap(), "image/jpeg");
|
| 463 |
+
|
| 464 |
+
let body = res.into_body().collect().await.unwrap().to_bytes();
|
| 465 |
+
assert_eq!(body[0], 0xFF);
|
| 466 |
+
assert_eq!(body[1], 0xD8);
|
| 467 |
+
}
|
| 468 |
+
|
| 469 |
+
#[tokio::test]
|
| 470 |
+
async fn preview_logo_badge_size_accepted() {
|
| 471 |
+
let (app, _state) = common::setup_test_app().await;
|
| 472 |
+
let token = common::setup_admin(&app).await;
|
| 473 |
+
|
| 474 |
+
let res = app.clone().oneshot(
|
| 475 |
+
authed_request("GET", "/api/admin/preview/logo?badge_size=l&label_style=t", &token, None),
|
| 476 |
+
).await.unwrap();
|
| 477 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 478 |
+
}
|
| 479 |
+
|
| 480 |
+
#[tokio::test]
|
| 481 |
+
async fn preview_backdrop_badge_size_accepted() {
|
| 482 |
+
let (app, _state) = common::setup_test_app().await;
|
| 483 |
+
let token = common::setup_admin(&app).await;
|
| 484 |
+
|
| 485 |
+
let res = app.clone().oneshot(
|
| 486 |
+
authed_request("GET", "/api/admin/preview/backdrop?badge_size=xs&label_style=o", &token, None),
|
| 487 |
+
).await.unwrap();
|
| 488 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 489 |
+
}
|
| 490 |
+
|
| 491 |
+
// --- E2E: Settings affect image generation ---
|
| 492 |
+
|
| 493 |
+
#[tokio::test]
|
| 494 |
+
async fn preview_reflects_badge_direction_change() {
|
| 495 |
+
let (app, _state) = common::setup_test_app().await;
|
| 496 |
+
let token = common::setup_admin(&app).await;
|
| 497 |
+
|
| 498 |
+
let res_default = app.clone().oneshot(
|
| 499 |
+
authed_request("GET", "/api/admin/preview/poster?ratings_limit=3&badge_direction=d&position=l", &token, None),
|
| 500 |
+
).await.unwrap();
|
| 501 |
+
assert_eq!(res_default.status(), StatusCode::OK);
|
| 502 |
+
let body_default = res_default.into_body().collect().await.unwrap().to_bytes();
|
| 503 |
+
|
| 504 |
+
let res_h = app.clone().oneshot(
|
| 505 |
+
authed_request("GET", "/api/admin/preview/poster?ratings_limit=3&badge_direction=h&position=l", &token, None),
|
| 506 |
+
).await.unwrap();
|
| 507 |
+
assert_eq!(res_h.status(), StatusCode::OK);
|
| 508 |
+
let body_h = res_h.into_body().collect().await.unwrap().to_bytes();
|
| 509 |
+
|
| 510 |
+
assert_eq!(body_default[0], 0xFF);
|
| 511 |
+
assert_eq!(body_h[0], 0xFF);
|
| 512 |
+
// direction=d with position=l resolves to vertical, while direction=h is horizontal — different images
|
| 513 |
+
assert_ne!(body_default, body_h);
|
| 514 |
+
}
|
api/tests/preview.rs
CHANGED
|
@@ -241,7 +241,7 @@ async fn preview_respects_poster_position() {
|
|
| 241 |
let (app, _state) = common::setup_test_app().await;
|
| 242 |
let token = common::setup_admin(&app).await;
|
| 243 |
|
| 244 |
-
let res = app.clone().oneshot(authed_get("/api/admin/preview/poster?
|
| 245 |
assert_eq!(res.status(), StatusCode::OK);
|
| 246 |
assert_eq!(res.headers().get("content-type").unwrap(), "image/jpeg");
|
| 247 |
|
|
@@ -256,10 +256,10 @@ async fn preview_cache_differs_for_different_positions() {
|
|
| 256 |
let (app, _state) = common::setup_test_app().await;
|
| 257 |
let token = common::setup_admin(&app).await;
|
| 258 |
|
| 259 |
-
let res1 = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=2&ratings_order=imdb,rt&
|
| 260 |
let body1 = res1.into_body().collect().await.unwrap().to_bytes();
|
| 261 |
|
| 262 |
-
let res2 = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=2&ratings_order=imdb,rt&
|
| 263 |
let body2 = res2.into_body().collect().await.unwrap().to_bytes();
|
| 264 |
|
| 265 |
assert_eq!(body1[0], 0xFF);
|
|
@@ -267,11 +267,307 @@ async fn preview_cache_differs_for_different_positions() {
|
|
| 267 |
assert_ne!(body1, body2);
|
| 268 |
}
|
| 269 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 270 |
#[tokio::test]
|
| 271 |
async fn preview_rejects_invalid_poster_position() {
|
| 272 |
let (app, _state) = common::setup_test_app().await;
|
| 273 |
let token = common::setup_admin(&app).await;
|
| 274 |
|
| 275 |
-
let res = app.clone().oneshot(authed_get("/api/admin/preview/poster?
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 276 |
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 277 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 241 |
let (app, _state) = common::setup_test_app().await;
|
| 242 |
let token = common::setup_admin(&app).await;
|
| 243 |
|
| 244 |
+
let res = app.clone().oneshot(authed_get("/api/admin/preview/poster?position=l", &token)).await.unwrap();
|
| 245 |
assert_eq!(res.status(), StatusCode::OK);
|
| 246 |
assert_eq!(res.headers().get("content-type").unwrap(), "image/jpeg");
|
| 247 |
|
|
|
|
| 256 |
let (app, _state) = common::setup_test_app().await;
|
| 257 |
let token = common::setup_admin(&app).await;
|
| 258 |
|
| 259 |
+
let res1 = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=2&ratings_order=imdb,rt&position=bc", &token)).await.unwrap();
|
| 260 |
let body1 = res1.into_body().collect().await.unwrap().to_bytes();
|
| 261 |
|
| 262 |
+
let res2 = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=2&ratings_order=imdb,rt&position=l", &token)).await.unwrap();
|
| 263 |
let body2 = res2.into_body().collect().await.unwrap().to_bytes();
|
| 264 |
|
| 265 |
assert_eq!(body1[0], 0xFF);
|
|
|
|
| 267 |
assert_ne!(body1, body2);
|
| 268 |
}
|
| 269 |
|
| 270 |
+
|
| 271 |
+
/// Verify that the preview endpoint actually renders badges in the correct
|
| 272 |
+
/// region of the image by checking pixel data, not just HTTP status codes.
|
| 273 |
+
#[tokio::test]
|
| 274 |
+
async fn preview_position_places_badges_in_correct_region() {
|
| 275 |
+
let (app, _state) = common::setup_test_app().await;
|
| 276 |
+
let token = common::setup_admin(&app).await;
|
| 277 |
+
|
| 278 |
+
let params = "ratings_limit=3&ratings_order=imdb,tmdb,rt";
|
| 279 |
+
|
| 280 |
+
let res_tc = app.clone().oneshot(authed_get(
|
| 281 |
+
&format!("/api/admin/preview/poster?{params}&position=tc"), &token,
|
| 282 |
+
)).await.unwrap();
|
| 283 |
+
assert_eq!(res_tc.status(), StatusCode::OK);
|
| 284 |
+
let body_tc = res_tc.into_body().collect().await.unwrap().to_bytes();
|
| 285 |
+
|
| 286 |
+
let res_bc = app.clone().oneshot(authed_get(
|
| 287 |
+
&format!("/api/admin/preview/poster?{params}&position=bc"), &token,
|
| 288 |
+
)).await.unwrap();
|
| 289 |
+
assert_eq!(res_bc.status(), StatusCode::OK);
|
| 290 |
+
let body_bc = res_bc.into_body().collect().await.unwrap().to_bytes();
|
| 291 |
+
|
| 292 |
+
// The sample poster is a dark gray gradient (26–42 per channel).
|
| 293 |
+
// Badge pixels are significantly brighter. Compute the y-centroid of
|
| 294 |
+
// bright pixels to verify badge placement.
|
| 295 |
+
fn badge_y_centroid(jpeg: &[u8]) -> f64 {
|
| 296 |
+
let img = image::load_from_memory(jpeg).unwrap().to_rgba8();
|
| 297 |
+
let h = img.height() as f64;
|
| 298 |
+
let (mut sum_y, mut count) = (0u64, 0u64);
|
| 299 |
+
for (_, y, px) in img.enumerate_pixels() {
|
| 300 |
+
if px[0].max(px[1]).max(px[2]) > 80 {
|
| 301 |
+
sum_y += y as u64;
|
| 302 |
+
count += 1;
|
| 303 |
+
}
|
| 304 |
+
}
|
| 305 |
+
assert!(count > 0, "no badge pixels found");
|
| 306 |
+
sum_y as f64 / count as f64 / h
|
| 307 |
+
}
|
| 308 |
+
|
| 309 |
+
let tc_cy = badge_y_centroid(&body_tc);
|
| 310 |
+
let bc_cy = badge_y_centroid(&body_bc);
|
| 311 |
+
|
| 312 |
+
assert!(tc_cy < 0.33,
|
| 313 |
+
"TopCenter: badge y-centroid {tc_cy:.2} should be in top third");
|
| 314 |
+
assert!(bc_cy > 0.67,
|
| 315 |
+
"BottomCenter: badge y-centroid {bc_cy:.2} should be in bottom third");
|
| 316 |
+
}
|
| 317 |
+
|
| 318 |
#[tokio::test]
|
| 319 |
async fn preview_rejects_invalid_poster_position() {
|
| 320 |
let (app, _state) = common::setup_test_app().await;
|
| 321 |
let token = common::setup_admin(&app).await;
|
| 322 |
|
| 323 |
+
let res = app.clone().oneshot(authed_get("/api/admin/preview/poster?position=invalid", &token)).await.unwrap();
|
| 324 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 325 |
+
}
|
| 326 |
+
|
| 327 |
+
// --- Badge style tests ---
|
| 328 |
+
|
| 329 |
+
#[tokio::test]
|
| 330 |
+
async fn preview_accepts_all_badge_styles() {
|
| 331 |
+
let (app, _state) = common::setup_test_app().await;
|
| 332 |
+
let token = common::setup_admin(&app).await;
|
| 333 |
+
|
| 334 |
+
for style in ["h", "v", "d"] {
|
| 335 |
+
let res = app.clone().oneshot(authed_get(
|
| 336 |
+
&format!("/api/admin/preview/poster?badge_style={style}"), &token
|
| 337 |
+
)).await.unwrap();
|
| 338 |
+
assert_eq!(res.status(), StatusCode::OK, "badge_style={style} should be accepted");
|
| 339 |
+
assert_eq!(res.headers().get("content-type").unwrap(), "image/jpeg");
|
| 340 |
+
}
|
| 341 |
+
}
|
| 342 |
+
|
| 343 |
+
#[tokio::test]
|
| 344 |
+
async fn preview_rejects_invalid_badge_style() {
|
| 345 |
+
let (app, _state) = common::setup_test_app().await;
|
| 346 |
+
let token = common::setup_admin(&app).await;
|
| 347 |
+
|
| 348 |
+
let res = app.clone().oneshot(authed_get("/api/admin/preview/poster?badge_style=z", &token)).await.unwrap();
|
| 349 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 350 |
+
}
|
| 351 |
+
|
| 352 |
+
#[tokio::test]
|
| 353 |
+
async fn preview_badge_style_produces_different_images() {
|
| 354 |
+
let (app, _state) = common::setup_test_app().await;
|
| 355 |
+
let token = common::setup_admin(&app).await;
|
| 356 |
+
|
| 357 |
+
let res_h = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=3&badge_style=h", &token)).await.unwrap();
|
| 358 |
+
let body_h = res_h.into_body().collect().await.unwrap().to_bytes();
|
| 359 |
+
|
| 360 |
+
let res_v = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=3&badge_style=v", &token)).await.unwrap();
|
| 361 |
+
let body_v = res_v.into_body().collect().await.unwrap().to_bytes();
|
| 362 |
+
|
| 363 |
+
assert_eq!(body_h[0], 0xFF);
|
| 364 |
+
assert_eq!(body_v[0], 0xFF);
|
| 365 |
+
assert_ne!(body_h, body_v, "horizontal and vertical badge styles should produce different images");
|
| 366 |
+
}
|
| 367 |
+
|
| 368 |
+
// --- Label style tests ---
|
| 369 |
+
|
| 370 |
+
#[tokio::test]
|
| 371 |
+
async fn preview_accepts_all_label_styles() {
|
| 372 |
+
let (app, _state) = common::setup_test_app().await;
|
| 373 |
+
let token = common::setup_admin(&app).await;
|
| 374 |
+
|
| 375 |
+
for style in ["t", "i", "o"] {
|
| 376 |
+
let res = app.clone().oneshot(authed_get(
|
| 377 |
+
&format!("/api/admin/preview/poster?label_style={style}"), &token
|
| 378 |
+
)).await.unwrap();
|
| 379 |
+
assert_eq!(res.status(), StatusCode::OK, "label_style={style} should be accepted");
|
| 380 |
+
}
|
| 381 |
+
}
|
| 382 |
+
|
| 383 |
+
#[tokio::test]
|
| 384 |
+
async fn preview_rejects_invalid_label_style() {
|
| 385 |
+
let (app, _state) = common::setup_test_app().await;
|
| 386 |
+
let token = common::setup_admin(&app).await;
|
| 387 |
+
|
| 388 |
+
let res = app.clone().oneshot(authed_get("/api/admin/preview/poster?label_style=x", &token)).await.unwrap();
|
| 389 |
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 390 |
}
|
| 391 |
+
|
| 392 |
+
#[tokio::test]
|
| 393 |
+
async fn preview_label_style_produces_different_images() {
|
| 394 |
+
let (app, _state) = common::setup_test_app().await;
|
| 395 |
+
let token = common::setup_admin(&app).await;
|
| 396 |
+
|
| 397 |
+
let res_text = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=3&label_style=t", &token)).await.unwrap();
|
| 398 |
+
let body_text = res_text.into_body().collect().await.unwrap().to_bytes();
|
| 399 |
+
|
| 400 |
+
let res_icon = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=3&label_style=i", &token)).await.unwrap();
|
| 401 |
+
let body_icon = res_icon.into_body().collect().await.unwrap().to_bytes();
|
| 402 |
+
|
| 403 |
+
assert_eq!(body_text[0], 0xFF);
|
| 404 |
+
assert_eq!(body_icon[0], 0xFF);
|
| 405 |
+
assert_ne!(body_text, body_icon, "text and icon label styles should produce different images");
|
| 406 |
+
}
|
| 407 |
+
|
| 408 |
+
// --- Badge size tests ---
|
| 409 |
+
|
| 410 |
+
#[tokio::test]
|
| 411 |
+
async fn preview_accepts_all_badge_sizes() {
|
| 412 |
+
let (app, _state) = common::setup_test_app().await;
|
| 413 |
+
let token = common::setup_admin(&app).await;
|
| 414 |
+
|
| 415 |
+
for size in ["xs", "s", "m", "l", "xl"] {
|
| 416 |
+
let res = app.clone().oneshot(authed_get(
|
| 417 |
+
&format!("/api/admin/preview/poster?badge_size={size}"), &token
|
| 418 |
+
)).await.unwrap();
|
| 419 |
+
assert_eq!(res.status(), StatusCode::OK, "badge_size={size} should be accepted");
|
| 420 |
+
}
|
| 421 |
+
}
|
| 422 |
+
|
| 423 |
+
#[tokio::test]
|
| 424 |
+
async fn preview_rejects_invalid_badge_size() {
|
| 425 |
+
let (app, _state) = common::setup_test_app().await;
|
| 426 |
+
let token = common::setup_admin(&app).await;
|
| 427 |
+
|
| 428 |
+
let res = app.clone().oneshot(authed_get("/api/admin/preview/poster?badge_size=xxl", &token)).await.unwrap();
|
| 429 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 430 |
+
}
|
| 431 |
+
|
| 432 |
+
#[tokio::test]
|
| 433 |
+
async fn preview_badge_size_produces_different_images() {
|
| 434 |
+
let (app, _state) = common::setup_test_app().await;
|
| 435 |
+
let token = common::setup_admin(&app).await;
|
| 436 |
+
|
| 437 |
+
let res_xs = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=3&badge_size=xs", &token)).await.unwrap();
|
| 438 |
+
let body_xs = res_xs.into_body().collect().await.unwrap().to_bytes();
|
| 439 |
+
|
| 440 |
+
let res_xl = app.clone().oneshot(authed_get("/api/admin/preview/poster?ratings_limit=3&badge_size=xl", &token)).await.unwrap();
|
| 441 |
+
let body_xl = res_xl.into_body().collect().await.unwrap().to_bytes();
|
| 442 |
+
|
| 443 |
+
assert_eq!(body_xs[0], 0xFF);
|
| 444 |
+
assert_eq!(body_xl[0], 0xFF);
|
| 445 |
+
assert_ne!(body_xs, body_xl, "xs and xl badge sizes should produce different images");
|
| 446 |
+
}
|
| 447 |
+
|
| 448 |
+
// --- Badge direction tests ---
|
| 449 |
+
|
| 450 |
+
#[tokio::test]
|
| 451 |
+
async fn preview_accepts_all_badge_directions() {
|
| 452 |
+
let (app, _state) = common::setup_test_app().await;
|
| 453 |
+
let token = common::setup_admin(&app).await;
|
| 454 |
+
|
| 455 |
+
for dir in ["d", "h", "v"] {
|
| 456 |
+
let res = app.clone().oneshot(authed_get(
|
| 457 |
+
&format!("/api/admin/preview/poster?badge_direction={dir}"), &token
|
| 458 |
+
)).await.unwrap();
|
| 459 |
+
assert_eq!(res.status(), StatusCode::OK, "badge_direction={dir} should be accepted");
|
| 460 |
+
}
|
| 461 |
+
}
|
| 462 |
+
|
| 463 |
+
#[tokio::test]
|
| 464 |
+
async fn preview_rejects_invalid_badge_direction() {
|
| 465 |
+
let (app, _state) = common::setup_test_app().await;
|
| 466 |
+
let token = common::setup_admin(&app).await;
|
| 467 |
+
|
| 468 |
+
let res = app.clone().oneshot(authed_get("/api/admin/preview/poster?badge_direction=x", &token)).await.unwrap();
|
| 469 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 470 |
+
}
|
| 471 |
+
|
| 472 |
+
// --- Logo preview tests ---
|
| 473 |
+
|
| 474 |
+
#[tokio::test]
|
| 475 |
+
async fn preview_logo_returns_png() {
|
| 476 |
+
let (app, _state) = common::setup_test_app().await;
|
| 477 |
+
let token = common::setup_admin(&app).await;
|
| 478 |
+
|
| 479 |
+
let res = app.clone().oneshot(authed_get("/api/admin/preview/logo", &token)).await.unwrap();
|
| 480 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 481 |
+
assert_eq!(res.headers().get("content-type").unwrap(), "image/png");
|
| 482 |
+
|
| 483 |
+
let body = res.into_body().collect().await.unwrap().to_bytes();
|
| 484 |
+
assert_eq!(&body[..4], &[0x89, b'P', b'N', b'G']);
|
| 485 |
+
}
|
| 486 |
+
|
| 487 |
+
#[tokio::test]
|
| 488 |
+
async fn preview_logo_accepts_badge_style_and_size() {
|
| 489 |
+
let (app, _state) = common::setup_test_app().await;
|
| 490 |
+
let token = common::setup_admin(&app).await;
|
| 491 |
+
|
| 492 |
+
let res = app.clone().oneshot(authed_get(
|
| 493 |
+
"/api/admin/preview/logo?badge_style=h&badge_size=l&label_style=t", &token
|
| 494 |
+
)).await.unwrap();
|
| 495 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 496 |
+
}
|
| 497 |
+
|
| 498 |
+
// --- Backdrop preview tests ---
|
| 499 |
+
|
| 500 |
+
#[tokio::test]
|
| 501 |
+
async fn preview_backdrop_returns_jpeg() {
|
| 502 |
+
let (app, _state) = common::setup_test_app().await;
|
| 503 |
+
let token = common::setup_admin(&app).await;
|
| 504 |
+
|
| 505 |
+
let res = app.clone().oneshot(authed_get("/api/admin/preview/backdrop", &token)).await.unwrap();
|
| 506 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 507 |
+
assert_eq!(res.headers().get("content-type").unwrap(), "image/jpeg");
|
| 508 |
+
|
| 509 |
+
let body = res.into_body().collect().await.unwrap().to_bytes();
|
| 510 |
+
assert_eq!(body[0], 0xFF);
|
| 511 |
+
assert_eq!(body[1], 0xD8);
|
| 512 |
+
}
|
| 513 |
+
|
| 514 |
+
#[tokio::test]
|
| 515 |
+
async fn preview_backdrop_accepts_badge_style_and_size() {
|
| 516 |
+
let (app, _state) = common::setup_test_app().await;
|
| 517 |
+
let token = common::setup_admin(&app).await;
|
| 518 |
+
|
| 519 |
+
let res = app.clone().oneshot(authed_get(
|
| 520 |
+
"/api/admin/preview/backdrop?badge_style=v&badge_size=xs&label_style=o", &token
|
| 521 |
+
)).await.unwrap();
|
| 522 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 523 |
+
}
|
| 524 |
+
|
| 525 |
+
// --- Combined param tests ---
|
| 526 |
+
|
| 527 |
+
#[tokio::test]
|
| 528 |
+
async fn preview_all_new_params_combined() {
|
| 529 |
+
let (app, _state) = common::setup_test_app().await;
|
| 530 |
+
let token = common::setup_admin(&app).await;
|
| 531 |
+
|
| 532 |
+
let res = app.clone().oneshot(authed_get(
|
| 533 |
+
"/api/admin/preview/poster?ratings_limit=4&ratings_order=imdb,tmdb,rt,mc&position=tl&badge_style=v&label_style=i&badge_direction=v&badge_size=l",
|
| 534 |
+
&token
|
| 535 |
+
)).await.unwrap();
|
| 536 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 537 |
+
|
| 538 |
+
let body = res.into_body().collect().await.unwrap().to_bytes();
|
| 539 |
+
assert_eq!(body[0], 0xFF);
|
| 540 |
+
assert!(body.len() > 100);
|
| 541 |
+
}
|
| 542 |
+
|
| 543 |
+
#[tokio::test]
|
| 544 |
+
async fn preview_self_serve_logo() {
|
| 545 |
+
let (app, _state) = common::setup_test_app().await;
|
| 546 |
+
let api_key_token = common::setup_api_key_session(&app).await;
|
| 547 |
+
|
| 548 |
+
let req = Request::builder()
|
| 549 |
+
.uri("/api/key/me/preview/logo?badge_style=h&badge_size=s")
|
| 550 |
+
.header("authorization", format!("Bearer {api_key_token}"))
|
| 551 |
+
.body(Body::empty())
|
| 552 |
+
.unwrap();
|
| 553 |
+
|
| 554 |
+
let res = app.oneshot(req).await.unwrap();
|
| 555 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 556 |
+
assert_eq!(res.headers().get("content-type").unwrap(), "image/png");
|
| 557 |
+
}
|
| 558 |
+
|
| 559 |
+
#[tokio::test]
|
| 560 |
+
async fn preview_self_serve_backdrop() {
|
| 561 |
+
let (app, _state) = common::setup_test_app().await;
|
| 562 |
+
let api_key_token = common::setup_api_key_session(&app).await;
|
| 563 |
+
|
| 564 |
+
let req = Request::builder()
|
| 565 |
+
.uri("/api/key/me/preview/backdrop?badge_size=xl&label_style=t")
|
| 566 |
+
.header("authorization", format!("Bearer {api_key_token}"))
|
| 567 |
+
.body(Body::empty())
|
| 568 |
+
.unwrap();
|
| 569 |
+
|
| 570 |
+
let res = app.oneshot(req).await.unwrap();
|
| 571 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 572 |
+
assert_eq!(res.headers().get("content-type").unwrap(), "image/jpeg");
|
| 573 |
+
}
|
api/tests/query_overrides.rs
ADDED
|
@@ -0,0 +1,260 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
mod common;
|
| 2 |
+
|
| 3 |
+
use axum::body::Body;
|
| 4 |
+
use axum::http::{Request, StatusCode};
|
| 5 |
+
use http_body_util::BodyExt;
|
| 6 |
+
use tower::ServiceExt;
|
| 7 |
+
|
| 8 |
+
/// Helper: create an admin and API key, return the raw key.
|
| 9 |
+
async fn create_api_key(app: &axum::Router) -> String {
|
| 10 |
+
let token = common::setup_admin(app).await;
|
| 11 |
+
|
| 12 |
+
let req = Request::builder()
|
| 13 |
+
.method("POST")
|
| 14 |
+
.uri("/api/keys")
|
| 15 |
+
.header("content-type", "application/json")
|
| 16 |
+
.header("authorization", format!("Bearer {token}"))
|
| 17 |
+
.body(Body::from(r#"{"name":"override-test"}"#))
|
| 18 |
+
.unwrap();
|
| 19 |
+
|
| 20 |
+
let res = app.clone().oneshot(req).await.unwrap();
|
| 21 |
+
assert_eq!(res.status(), StatusCode::OK);
|
| 22 |
+
let body = res.into_body().collect().await.unwrap().to_bytes();
|
| 23 |
+
let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
|
| 24 |
+
json["key"].as_str().unwrap().to_string()
|
| 25 |
+
}
|
| 26 |
+
|
| 27 |
+
// --- Valid override parameters accepted ---
|
| 28 |
+
|
| 29 |
+
#[tokio::test]
|
| 30 |
+
async fn poster_badge_style_accepted() {
|
| 31 |
+
let (app, _) = common::setup_test_app().await;
|
| 32 |
+
let api_key = create_api_key(&app).await;
|
| 33 |
+
|
| 34 |
+
let req = Request::builder()
|
| 35 |
+
.uri(format!(
|
| 36 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?badge_style=h"
|
| 37 |
+
))
|
| 38 |
+
.body(Body::empty())
|
| 39 |
+
.unwrap();
|
| 40 |
+
|
| 41 |
+
let res = app.oneshot(req).await.unwrap();
|
| 42 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 43 |
+
}
|
| 44 |
+
|
| 45 |
+
#[tokio::test]
|
| 46 |
+
async fn poster_ratings_limit_accepted() {
|
| 47 |
+
let (app, _) = common::setup_test_app().await;
|
| 48 |
+
let api_key = create_api_key(&app).await;
|
| 49 |
+
|
| 50 |
+
let req = Request::builder()
|
| 51 |
+
.uri(format!(
|
| 52 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?ratings_limit=3"
|
| 53 |
+
))
|
| 54 |
+
.body(Body::empty())
|
| 55 |
+
.unwrap();
|
| 56 |
+
|
| 57 |
+
let res = app.oneshot(req).await.unwrap();
|
| 58 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 59 |
+
}
|
| 60 |
+
|
| 61 |
+
#[tokio::test]
|
| 62 |
+
async fn poster_all_overrides_accepted() {
|
| 63 |
+
let (app, _) = common::setup_test_app().await;
|
| 64 |
+
let api_key = create_api_key(&app).await;
|
| 65 |
+
|
| 66 |
+
let req = Request::builder()
|
| 67 |
+
.uri(format!(
|
| 68 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?badge_style=v&label_style=i&badge_size=l&badge_direction=h&position=tl&ratings_limit=5&ratings_order=imdb,tmdb&poster_source=t&fanart_textless=false"
|
| 69 |
+
))
|
| 70 |
+
.body(Body::empty())
|
| 71 |
+
.unwrap();
|
| 72 |
+
|
| 73 |
+
let res = app.oneshot(req).await.unwrap();
|
| 74 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 75 |
+
}
|
| 76 |
+
|
| 77 |
+
#[tokio::test]
|
| 78 |
+
async fn logo_badge_style_accepted() {
|
| 79 |
+
let (app, _) = common::setup_test_app().await;
|
| 80 |
+
let api_key = create_api_key(&app).await;
|
| 81 |
+
|
| 82 |
+
let req = Request::builder()
|
| 83 |
+
.uri(format!(
|
| 84 |
+
"/{api_key}/imdb/logo-default/tt0000001.png?badge_style=h&ratings_limit=2&label_style=o"
|
| 85 |
+
))
|
| 86 |
+
.body(Body::empty())
|
| 87 |
+
.unwrap();
|
| 88 |
+
|
| 89 |
+
let res = app.oneshot(req).await.unwrap();
|
| 90 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 91 |
+
}
|
| 92 |
+
|
| 93 |
+
#[tokio::test]
|
| 94 |
+
async fn backdrop_badge_size_accepted() {
|
| 95 |
+
let (app, _) = common::setup_test_app().await;
|
| 96 |
+
let api_key = create_api_key(&app).await;
|
| 97 |
+
|
| 98 |
+
let req = Request::builder()
|
| 99 |
+
.uri(format!(
|
| 100 |
+
"/{api_key}/imdb/backdrop-default/tt0000001.jpg?badge_size=xl&badge_style=v"
|
| 101 |
+
))
|
| 102 |
+
.body(Body::empty())
|
| 103 |
+
.unwrap();
|
| 104 |
+
|
| 105 |
+
let res = app.oneshot(req).await.unwrap();
|
| 106 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 107 |
+
}
|
| 108 |
+
|
| 109 |
+
// --- Invalid override parameters rejected ---
|
| 110 |
+
|
| 111 |
+
#[tokio::test]
|
| 112 |
+
async fn poster_invalid_ratings_limit_rejected() {
|
| 113 |
+
let (app, _) = common::setup_test_app().await;
|
| 114 |
+
let api_key = create_api_key(&app).await;
|
| 115 |
+
|
| 116 |
+
let req = Request::builder()
|
| 117 |
+
.uri(format!(
|
| 118 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?ratings_limit=9"
|
| 119 |
+
))
|
| 120 |
+
.body(Body::empty())
|
| 121 |
+
.unwrap();
|
| 122 |
+
|
| 123 |
+
let res = app.oneshot(req).await.unwrap();
|
| 124 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 125 |
+
}
|
| 126 |
+
|
| 127 |
+
#[tokio::test]
|
| 128 |
+
async fn poster_invalid_ratings_order_rejected() {
|
| 129 |
+
let (app, _) = common::setup_test_app().await;
|
| 130 |
+
let api_key = create_api_key(&app).await;
|
| 131 |
+
|
| 132 |
+
let req = Request::builder()
|
| 133 |
+
.uri(format!(
|
| 134 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?ratings_order=bogus_source"
|
| 135 |
+
))
|
| 136 |
+
.body(Body::empty())
|
| 137 |
+
.unwrap();
|
| 138 |
+
|
| 139 |
+
let res = app.oneshot(req).await.unwrap();
|
| 140 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 141 |
+
}
|
| 142 |
+
|
| 143 |
+
#[tokio::test]
|
| 144 |
+
async fn poster_invalid_badge_style_rejected() {
|
| 145 |
+
let (app, _) = common::setup_test_app().await;
|
| 146 |
+
let api_key = create_api_key(&app).await;
|
| 147 |
+
|
| 148 |
+
let req = Request::builder()
|
| 149 |
+
.uri(format!(
|
| 150 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?badge_style=z"
|
| 151 |
+
))
|
| 152 |
+
.body(Body::empty())
|
| 153 |
+
.unwrap();
|
| 154 |
+
|
| 155 |
+
let res = app.oneshot(req).await.unwrap();
|
| 156 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 157 |
+
}
|
| 158 |
+
|
| 159 |
+
#[tokio::test]
|
| 160 |
+
async fn poster_negative_ratings_limit_rejected() {
|
| 161 |
+
let (app, _) = common::setup_test_app().await;
|
| 162 |
+
let api_key = create_api_key(&app).await;
|
| 163 |
+
|
| 164 |
+
let req = Request::builder()
|
| 165 |
+
.uri(format!(
|
| 166 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?ratings_limit=-1"
|
| 167 |
+
))
|
| 168 |
+
.body(Body::empty())
|
| 169 |
+
.unwrap();
|
| 170 |
+
|
| 171 |
+
let res = app.oneshot(req).await.unwrap();
|
| 172 |
+
assert_eq!(res.status(), StatusCode::BAD_REQUEST);
|
| 173 |
+
}
|
| 174 |
+
|
| 175 |
+
// --- Poster-only params silently ignored on logo/backdrop ---
|
| 176 |
+
|
| 177 |
+
#[tokio::test]
|
| 178 |
+
async fn logo_poster_only_params_ignored() {
|
| 179 |
+
let (app, _) = common::setup_test_app().await;
|
| 180 |
+
let api_key = create_api_key(&app).await;
|
| 181 |
+
|
| 182 |
+
// position and badge_direction are poster-only but should not cause errors on logo
|
| 183 |
+
let req = Request::builder()
|
| 184 |
+
.uri(format!(
|
| 185 |
+
"/{api_key}/imdb/logo-default/tt0000001.png?position=tl&badge_direction=h&poster_source=f&fanart_textless=true"
|
| 186 |
+
))
|
| 187 |
+
.body(Body::empty())
|
| 188 |
+
.unwrap();
|
| 189 |
+
|
| 190 |
+
let res = app.oneshot(req).await.unwrap();
|
| 191 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 192 |
+
}
|
| 193 |
+
|
| 194 |
+
#[tokio::test]
|
| 195 |
+
async fn backdrop_poster_only_params_ignored() {
|
| 196 |
+
let (app, _) = common::setup_test_app().await;
|
| 197 |
+
let api_key = create_api_key(&app).await;
|
| 198 |
+
|
| 199 |
+
let req = Request::builder()
|
| 200 |
+
.uri(format!(
|
| 201 |
+
"/{api_key}/imdb/backdrop-default/tt0000001.jpg?position=br&badge_direction=v&poster_source=t"
|
| 202 |
+
))
|
| 203 |
+
.body(Body::empty())
|
| 204 |
+
.unwrap();
|
| 205 |
+
|
| 206 |
+
let res = app.oneshot(req).await.unwrap();
|
| 207 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 208 |
+
}
|
| 209 |
+
|
| 210 |
+
// --- No overrides still works ---
|
| 211 |
+
|
| 212 |
+
#[tokio::test]
|
| 213 |
+
async fn poster_no_overrides_accepted() {
|
| 214 |
+
let (app, _) = common::setup_test_app().await;
|
| 215 |
+
let api_key = create_api_key(&app).await;
|
| 216 |
+
|
| 217 |
+
let req = Request::builder()
|
| 218 |
+
.uri(format!(
|
| 219 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg"
|
| 220 |
+
))
|
| 221 |
+
.body(Body::empty())
|
| 222 |
+
.unwrap();
|
| 223 |
+
|
| 224 |
+
let res = app.oneshot(req).await.unwrap();
|
| 225 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 226 |
+
}
|
| 227 |
+
|
| 228 |
+
// --- Ratings limit boundary values ---
|
| 229 |
+
|
| 230 |
+
#[tokio::test]
|
| 231 |
+
async fn poster_ratings_limit_zero_accepted() {
|
| 232 |
+
let (app, _) = common::setup_test_app().await;
|
| 233 |
+
let api_key = create_api_key(&app).await;
|
| 234 |
+
|
| 235 |
+
let req = Request::builder()
|
| 236 |
+
.uri(format!(
|
| 237 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?ratings_limit=0"
|
| 238 |
+
))
|
| 239 |
+
.body(Body::empty())
|
| 240 |
+
.unwrap();
|
| 241 |
+
|
| 242 |
+
let res = app.oneshot(req).await.unwrap();
|
| 243 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 244 |
+
}
|
| 245 |
+
|
| 246 |
+
#[tokio::test]
|
| 247 |
+
async fn poster_ratings_limit_eight_accepted() {
|
| 248 |
+
let (app, _) = common::setup_test_app().await;
|
| 249 |
+
let api_key = create_api_key(&app).await;
|
| 250 |
+
|
| 251 |
+
let req = Request::builder()
|
| 252 |
+
.uri(format!(
|
| 253 |
+
"/{api_key}/imdb/poster-default/tt0000001.jpg?ratings_limit=8"
|
| 254 |
+
))
|
| 255 |
+
.body(Body::empty())
|
| 256 |
+
.unwrap();
|
| 257 |
+
|
| 258 |
+
let res = app.oneshot(req).await.unwrap();
|
| 259 |
+
assert_ne!(res.status(), StatusCode::BAD_REQUEST);
|
| 260 |
+
}
|
scripts/regenerate-examples.sh
CHANGED
|
@@ -88,7 +88,7 @@ echo "--- Positions ---"
|
|
| 88 |
for pos in tl tc tr r bl bc br l; do
|
| 89 |
echo -n "pos-$pos... "
|
| 90 |
curl -sf "${AUTH[@]}" \
|
| 91 |
-
"$PREVIEW/poster?
|
| 92 |
-o "$OUT/pos-$pos.jpg"
|
| 93 |
echo "OK"
|
| 94 |
done
|
|
|
|
| 88 |
for pos in tl tc tr r bl bc br l; do
|
| 89 |
echo -n "pos-$pos... "
|
| 90 |
curl -sf "${AUTH[@]}" \
|
| 91 |
+
"$PREVIEW/poster?position=$pos" \
|
| 92 |
-o "$OUT/pos-$pos.jpg"
|
| 93 |
echo "OK"
|
| 94 |
done
|
scripts/test.sh
CHANGED
|
@@ -28,6 +28,7 @@ echo "=== E2E tests ==="
|
|
| 28 |
cleanup() {
|
| 29 |
echo "=== Tearing down ==="
|
| 30 |
$CTR rm -f "$CONTAINER_NAME" 2>/dev/null || true
|
|
|
|
| 31 |
}
|
| 32 |
trap cleanup EXIT
|
| 33 |
|
|
|
|
| 28 |
cleanup() {
|
| 29 |
echo "=== Tearing down ==="
|
| 30 |
$CTR rm -f "$CONTAINER_NAME" 2>/dev/null || true
|
| 31 |
+
$CTR rmi -f "$IMAGE_NAME" 2>/dev/null || true
|
| 32 |
}
|
| 33 |
trap cleanup EXIT
|
| 34 |
|
web/src/__tests__/components/FreeApiKeyCard.spec.ts
CHANGED
|
@@ -27,7 +27,7 @@ function mountCard(freeApiKeyEnabled = true) {
|
|
| 27 |
plugins: [pinia],
|
| 28 |
stubs: {
|
| 29 |
Select: SelectStub,
|
| 30 |
-
SelectTrigger: { template: '<span><slot /></span>' },
|
| 31 |
SelectValue: { template: '<span>{{ placeholder }}</span>', props: ['placeholder'] },
|
| 32 |
SelectContent: { template: '<span><slot /></span>' },
|
| 33 |
SelectItem: { template: '<span><slot /></span>', props: ['value'] },
|
|
@@ -51,17 +51,21 @@ function mountCard(freeApiKeyEnabled = true) {
|
|
| 51 |
}
|
| 52 |
|
| 53 |
/**
|
| 54 |
-
*
|
| 55 |
-
*
|
| 56 |
*/
|
| 57 |
-
function
|
| 58 |
-
|
| 59 |
-
|
| 60 |
-
|
| 61 |
-
|
| 62 |
-
|
| 63 |
-
const
|
| 64 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
| 65 |
await flushPromises()
|
| 66 |
}
|
| 67 |
|
|
@@ -95,22 +99,21 @@ describe('FreeApiKeyCard', () => {
|
|
| 95 |
const wrapper = mountCard(true)
|
| 96 |
expect(findCurlCode(wrapper).text()).toContain('.jpg')
|
| 97 |
|
| 98 |
-
await
|
| 99 |
expect(findCurlCode(wrapper).text()).toContain('.png')
|
| 100 |
})
|
| 101 |
|
| 102 |
it('sizeOptions excludes small for poster, includes small for backdrop', async () => {
|
| 103 |
const wrapper = mountCard(true)
|
| 104 |
// Default is poster — set "small" then switch imageType to trigger the watch
|
| 105 |
-
await
|
| 106 |
-
//
|
| 107 |
-
|
| 108 |
-
await setSelect(wrapper, 1, 'logo') // triggers watch → small invalid for logo → reset
|
| 109 |
expect(findCurlCode(wrapper).text()).not.toContain('imageSize=small')
|
| 110 |
|
| 111 |
// Switch to backdrop — "small" should be valid and persist
|
| 112 |
-
await
|
| 113 |
-
await
|
| 114 |
expect(findCurlCode(wrapper).text()).toContain('imageSize=small')
|
| 115 |
})
|
| 116 |
|
|
@@ -118,13 +121,13 @@ describe('FreeApiKeyCard', () => {
|
|
| 118 |
const wrapper = mountCard(true)
|
| 119 |
|
| 120 |
// Switch to backdrop
|
| 121 |
-
await
|
| 122 |
// Set size to small (valid for backdrop)
|
| 123 |
-
await
|
| 124 |
expect(findCurlCode(wrapper).text()).toContain('imageSize=small')
|
| 125 |
|
| 126 |
// Switch back to poster — "small" is invalid, should reset to default
|
| 127 |
-
await
|
| 128 |
expect(findCurlCode(wrapper).text()).not.toContain('imageSize=small')
|
| 129 |
})
|
| 130 |
|
|
@@ -180,10 +183,8 @@ describe('FreeApiKeyCard', () => {
|
|
| 180 |
it('queryString includes lang, imageSize params when set', async () => {
|
| 181 |
const wrapper = mountCard(true)
|
| 182 |
|
| 183 |
-
|
| 184 |
-
await
|
| 185 |
-
// Set imageSize
|
| 186 |
-
await setSelect(wrapper, 2, 'large')
|
| 187 |
|
| 188 |
const curlText = findCurlCode(wrapper).text()
|
| 189 |
expect(curlText).toContain('lang=en')
|
|
@@ -196,10 +197,38 @@ describe('FreeApiKeyCard', () => {
|
|
| 196 |
const getPlaceholder = () => wrapper.find('input:not([type="checkbox"])').attributes('placeholder')
|
| 197 |
expect(getPlaceholder()).toBe('tt0013442')
|
| 198 |
|
| 199 |
-
await
|
| 200 |
expect(getPlaceholder()).toBe('movie-872585')
|
| 201 |
|
| 202 |
-
await
|
| 203 |
expect(getPlaceholder()).toBe('253573')
|
| 204 |
})
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 205 |
})
|
|
|
|
| 27 |
plugins: [pinia],
|
| 28 |
stubs: {
|
| 29 |
Select: SelectStub,
|
| 30 |
+
SelectTrigger: { template: '<span :id="id"><slot /></span>', props: ['id', 'ariaLabel', 'class'] },
|
| 31 |
SelectValue: { template: '<span>{{ placeholder }}</span>', props: ['placeholder'] },
|
| 32 |
SelectContent: { template: '<span><slot /></span>' },
|
| 33 |
SelectItem: { template: '<span><slot /></span>', props: ['value'] },
|
|
|
|
| 51 |
}
|
| 52 |
|
| 53 |
/**
|
| 54 |
+
* Set a Select's value by finding its SelectTrigger via id,
|
| 55 |
+
* then emitting on the parent Select component.
|
| 56 |
*/
|
| 57 |
+
async function setSelectById(wrapper: VueWrapper, triggerId: string, value: string) {
|
| 58 |
+
const trigger = wrapper.find(`#${triggerId}`)
|
| 59 |
+
if (!trigger.exists()) {
|
| 60 |
+
throw new Error(`SelectTrigger with id="${triggerId}" not found`)
|
| 61 |
+
}
|
| 62 |
+
// Walk up to find the parent Select stub component
|
| 63 |
+
const selectComponents = wrapper.findAllComponents(SelectStub)
|
| 64 |
+
const parent = selectComponents.find(s => s.find(`#${triggerId}`).exists())
|
| 65 |
+
if (!parent) {
|
| 66 |
+
throw new Error(`Parent Select for trigger id="${triggerId}" not found`)
|
| 67 |
+
}
|
| 68 |
+
parent.vm.$emit('update:modelValue', value)
|
| 69 |
await flushPromises()
|
| 70 |
}
|
| 71 |
|
|
|
|
| 99 |
const wrapper = mountCard(true)
|
| 100 |
expect(findCurlCode(wrapper).text()).toContain('.jpg')
|
| 101 |
|
| 102 |
+
await setSelectById(wrapper, 'free-image-type', 'logo')
|
| 103 |
expect(findCurlCode(wrapper).text()).toContain('.png')
|
| 104 |
})
|
| 105 |
|
| 106 |
it('sizeOptions excludes small for poster, includes small for backdrop', async () => {
|
| 107 |
const wrapper = mountCard(true)
|
| 108 |
// Default is poster — set "small" then switch imageType to trigger the watch
|
| 109 |
+
await setSelectById(wrapper, 'free-image-size', 'small')
|
| 110 |
+
// Switch imageType away to trigger the reset (small invalid for logo)
|
| 111 |
+
await setSelectById(wrapper, 'free-image-type', 'logo')
|
|
|
|
| 112 |
expect(findCurlCode(wrapper).text()).not.toContain('imageSize=small')
|
| 113 |
|
| 114 |
// Switch to backdrop — "small" should be valid and persist
|
| 115 |
+
await setSelectById(wrapper, 'free-image-type', 'backdrop')
|
| 116 |
+
await setSelectById(wrapper, 'free-image-size', 'small')
|
| 117 |
expect(findCurlCode(wrapper).text()).toContain('imageSize=small')
|
| 118 |
})
|
| 119 |
|
|
|
|
| 121 |
const wrapper = mountCard(true)
|
| 122 |
|
| 123 |
// Switch to backdrop
|
| 124 |
+
await setSelectById(wrapper, 'free-image-type', 'backdrop')
|
| 125 |
// Set size to small (valid for backdrop)
|
| 126 |
+
await setSelectById(wrapper, 'free-image-size', 'small')
|
| 127 |
expect(findCurlCode(wrapper).text()).toContain('imageSize=small')
|
| 128 |
|
| 129 |
// Switch back to poster — "small" is invalid, should reset to default
|
| 130 |
+
await setSelectById(wrapper, 'free-image-type', 'poster')
|
| 131 |
expect(findCurlCode(wrapper).text()).not.toContain('imageSize=small')
|
| 132 |
})
|
| 133 |
|
|
|
|
| 183 |
it('queryString includes lang, imageSize params when set', async () => {
|
| 184 |
const wrapper = mountCard(true)
|
| 185 |
|
| 186 |
+
await setSelectById(wrapper, 'free-lang', 'en')
|
| 187 |
+
await setSelectById(wrapper, 'free-image-size', 'large')
|
|
|
|
|
|
|
| 188 |
|
| 189 |
const curlText = findCurlCode(wrapper).text()
|
| 190 |
expect(curlText).toContain('lang=en')
|
|
|
|
| 197 |
const getPlaceholder = () => wrapper.find('input:not([type="checkbox"])').attributes('placeholder')
|
| 198 |
expect(getPlaceholder()).toBe('tt0013442')
|
| 199 |
|
| 200 |
+
await setSelectById(wrapper, 'free-id-type', 'tmdb')
|
| 201 |
expect(getPlaceholder()).toBe('movie-872585')
|
| 202 |
|
| 203 |
+
await setSelectById(wrapper, 'free-id-type', 'tvdb')
|
| 204 |
expect(getPlaceholder()).toBe('253573')
|
| 205 |
})
|
| 206 |
+
|
| 207 |
+
it('resets poster-only controls when switching away from poster', async () => {
|
| 208 |
+
const wrapper = mountCard(true)
|
| 209 |
+
|
| 210 |
+
// Set poster-only controls
|
| 211 |
+
await setSelectById(wrapper, 'free-poster-position', 'tl')
|
| 212 |
+
await setSelectById(wrapper, 'free-badge-direction', 'v')
|
| 213 |
+
await setSelectById(wrapper, 'free-poster-source', 'f')
|
| 214 |
+
await setSelectById(wrapper, 'free-fanart-textless', 'true')
|
| 215 |
+
expect(findCurlCode(wrapper).text()).toContain('position=tl')
|
| 216 |
+
expect(findCurlCode(wrapper).text()).toContain('badge_direction=v')
|
| 217 |
+
expect(findCurlCode(wrapper).text()).toContain('poster_source=f')
|
| 218 |
+
expect(findCurlCode(wrapper).text()).toContain('fanart_textless=true')
|
| 219 |
+
|
| 220 |
+
// Switch to logo — poster-only controls should reset
|
| 221 |
+
await setSelectById(wrapper, 'free-image-type', 'logo')
|
| 222 |
+
expect(findCurlCode(wrapper).text()).not.toContain('position=')
|
| 223 |
+
expect(findCurlCode(wrapper).text()).not.toContain('badge_direction=')
|
| 224 |
+
expect(findCurlCode(wrapper).text()).not.toContain('poster_source=')
|
| 225 |
+
expect(findCurlCode(wrapper).text()).not.toContain('fanart_textless=')
|
| 226 |
+
|
| 227 |
+
// Switch back to poster — controls should be at defaults (not persisted)
|
| 228 |
+
await setSelectById(wrapper, 'free-image-type', 'poster')
|
| 229 |
+
expect(findCurlCode(wrapper).text()).not.toContain('position=')
|
| 230 |
+
expect(findCurlCode(wrapper).text()).not.toContain('badge_direction=')
|
| 231 |
+
expect(findCurlCode(wrapper).text()).not.toContain('poster_source=')
|
| 232 |
+
expect(findCurlCode(wrapper).text()).not.toContain('fanart_textless=')
|
| 233 |
+
})
|
| 234 |
})
|
web/src/__tests__/components/RatingsOrderList.spec.ts
ADDED
|
@@ -0,0 +1,149 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import { describe, it, expect } from 'vitest'
|
| 2 |
+
import { mount } from '@vue/test-utils'
|
| 3 |
+
import RatingsOrderList from '@/components/RatingsOrderList.vue'
|
| 4 |
+
import { ALL_RATING_SOURCES } from '@/lib/constants'
|
| 5 |
+
|
| 6 |
+
function mountWithModel(initial: string[] = ['imdb', 'tmdb', 'rt'], compact = false) {
|
| 7 |
+
const wrapper = mount(RatingsOrderList, {
|
| 8 |
+
props: {
|
| 9 |
+
modelValue: initial,
|
| 10 |
+
compact,
|
| 11 |
+
},
|
| 12 |
+
})
|
| 13 |
+
return wrapper
|
| 14 |
+
}
|
| 15 |
+
|
| 16 |
+
describe('RatingsOrderList', () => {
|
| 17 |
+
it('renders all items in correct order', () => {
|
| 18 |
+
const order = ['imdb', 'tmdb', 'rt']
|
| 19 |
+
const wrapper = mountWithModel(order)
|
| 20 |
+
|
| 21 |
+
const rows = wrapper.findAll('.flex.items-center')
|
| 22 |
+
expect(rows).toHaveLength(3)
|
| 23 |
+
|
| 24 |
+
// Check labels appear in order
|
| 25 |
+
const text = wrapper.text()
|
| 26 |
+
expect(text).toContain('IMDb')
|
| 27 |
+
expect(text).toContain('TMDB')
|
| 28 |
+
expect(text).toContain('Rotten Tomatoes (Critics)')
|
| 29 |
+
})
|
| 30 |
+
|
| 31 |
+
it('displays 1-based index numbers', () => {
|
| 32 |
+
const wrapper = mountWithModel(['imdb', 'tmdb', 'rt'])
|
| 33 |
+
|
| 34 |
+
const indices = wrapper.findAll('.text-muted-foreground.text-xs')
|
| 35 |
+
expect(indices[0].text()).toBe('1')
|
| 36 |
+
expect(indices[1].text()).toBe('2')
|
| 37 |
+
expect(indices[2].text()).toBe('3')
|
| 38 |
+
})
|
| 39 |
+
|
| 40 |
+
it('renders colored dots from ALL_RATING_SOURCES', () => {
|
| 41 |
+
const wrapper = mountWithModel(['imdb'])
|
| 42 |
+
const dot = wrapper.find('.rounded-full')
|
| 43 |
+
// Style is set via :style binding — check that backgroundColor is set
|
| 44 |
+
expect(dot.attributes('style')).toContain('background-color')
|
| 45 |
+
})
|
| 46 |
+
|
| 47 |
+
it('disables up button on first item', () => {
|
| 48 |
+
const wrapper = mountWithModel(['imdb', 'tmdb', 'rt'])
|
| 49 |
+
const buttons = wrapper.findAll('button')
|
| 50 |
+
// First row: up button (index 0), down button (index 1)
|
| 51 |
+
expect((buttons[0].element as HTMLButtonElement).disabled).toBe(true)
|
| 52 |
+
})
|
| 53 |
+
|
| 54 |
+
it('disables down button on last item', () => {
|
| 55 |
+
const wrapper = mountWithModel(['imdb', 'tmdb', 'rt'])
|
| 56 |
+
const buttons = wrapper.findAll('button')
|
| 57 |
+
// Last row: up button (index 4), down button (index 5)
|
| 58 |
+
const lastDown = buttons[buttons.length - 1]
|
| 59 |
+
expect((lastDown.element as HTMLButtonElement).disabled).toBe(true)
|
| 60 |
+
})
|
| 61 |
+
|
| 62 |
+
it('enables up/down buttons on middle items', () => {
|
| 63 |
+
const wrapper = mountWithModel(['imdb', 'tmdb', 'rt'])
|
| 64 |
+
const buttons = wrapper.findAll('button')
|
| 65 |
+
// Middle row (tmdb): up button (index 2), down button (index 3)
|
| 66 |
+
expect((buttons[2].element as HTMLButtonElement).disabled).toBe(false)
|
| 67 |
+
expect((buttons[3].element as HTMLButtonElement).disabled).toBe(false)
|
| 68 |
+
})
|
| 69 |
+
|
| 70 |
+
it('emits update:modelValue with swapped items when moving up', async () => {
|
| 71 |
+
const wrapper = mountWithModel(['imdb', 'tmdb', 'rt'])
|
| 72 |
+
const buttons = wrapper.findAll('button')
|
| 73 |
+
// Click "up" on tmdb (second row, up button = index 2)
|
| 74 |
+
await buttons[2].trigger('click')
|
| 75 |
+
|
| 76 |
+
const emitted = wrapper.emitted('update:modelValue')
|
| 77 |
+
expect(emitted).toBeTruthy()
|
| 78 |
+
expect(emitted![0][0]).toEqual(['tmdb', 'imdb', 'rt'])
|
| 79 |
+
})
|
| 80 |
+
|
| 81 |
+
it('emits update:modelValue with swapped items when moving down', async () => {
|
| 82 |
+
const wrapper = mountWithModel(['imdb', 'tmdb', 'rt'])
|
| 83 |
+
const buttons = wrapper.findAll('button')
|
| 84 |
+
// Click "down" on tmdb (second row, down button = index 3)
|
| 85 |
+
await buttons[3].trigger('click')
|
| 86 |
+
|
| 87 |
+
const emitted = wrapper.emitted('update:modelValue')
|
| 88 |
+
expect(emitted).toBeTruthy()
|
| 89 |
+
expect(emitted![0][0]).toEqual(['imdb', 'rt', 'tmdb'])
|
| 90 |
+
})
|
| 91 |
+
|
| 92 |
+
it('does not emit when clicking disabled up button on first item', async () => {
|
| 93 |
+
const wrapper = mountWithModel(['imdb', 'tmdb'])
|
| 94 |
+
const buttons = wrapper.findAll('button')
|
| 95 |
+
// First item's up button is disabled — clicking should not emit
|
| 96 |
+
await buttons[0].trigger('click')
|
| 97 |
+
|
| 98 |
+
const emitted = wrapper.emitted('update:modelValue')
|
| 99 |
+
expect(emitted).toBeUndefined()
|
| 100 |
+
})
|
| 101 |
+
|
| 102 |
+
it('does not emit when clicking disabled down button on last item', async () => {
|
| 103 |
+
const wrapper = mountWithModel(['imdb', 'tmdb'])
|
| 104 |
+
const buttons = wrapper.findAll('button')
|
| 105 |
+
// Last item's down button
|
| 106 |
+
const lastDown = buttons[buttons.length - 1]
|
| 107 |
+
await lastDown.trigger('click')
|
| 108 |
+
|
| 109 |
+
const emitted = wrapper.emitted('update:modelValue')
|
| 110 |
+
expect(emitted).toBeUndefined()
|
| 111 |
+
})
|
| 112 |
+
|
| 113 |
+
it('handles single-item list (both buttons disabled)', () => {
|
| 114 |
+
const wrapper = mountWithModel(['imdb'])
|
| 115 |
+
const buttons = wrapper.findAll('button')
|
| 116 |
+
expect(buttons).toHaveLength(2)
|
| 117 |
+
expect((buttons[0].element as HTMLButtonElement).disabled).toBe(true)
|
| 118 |
+
expect((buttons[1].element as HTMLButtonElement).disabled).toBe(true)
|
| 119 |
+
})
|
| 120 |
+
|
| 121 |
+
it('falls back to key when rating source not found', () => {
|
| 122 |
+
const wrapper = mountWithModel(['unknown_source'])
|
| 123 |
+
expect(wrapper.text()).toContain('unknown_source')
|
| 124 |
+
})
|
| 125 |
+
|
| 126 |
+
it('applies compact styling when compact prop is true', () => {
|
| 127 |
+
const wrapper = mountWithModel(['imdb', 'tmdb'], true)
|
| 128 |
+
const container = wrapper.find('.space-y-0\\.5')
|
| 129 |
+
expect(container.exists()).toBe(true)
|
| 130 |
+
})
|
| 131 |
+
|
| 132 |
+
it('applies normal styling when compact is false', () => {
|
| 133 |
+
const wrapper = mountWithModel(['imdb', 'tmdb'], false)
|
| 134 |
+
const container = wrapper.find('.space-y-1')
|
| 135 |
+
expect(container.exists()).toBe(true)
|
| 136 |
+
})
|
| 137 |
+
|
| 138 |
+
it('handles all 8 rating sources', () => {
|
| 139 |
+
const allKeys = ALL_RATING_SOURCES.map(s => s.key)
|
| 140 |
+
const wrapper = mountWithModel(allKeys)
|
| 141 |
+
|
| 142 |
+
const rows = wrapper.findAll('.flex.items-center')
|
| 143 |
+
expect(rows).toHaveLength(8)
|
| 144 |
+
|
| 145 |
+
// Verify all up/down buttons exist (2 per row)
|
| 146 |
+
const buttons = wrapper.findAll('button')
|
| 147 |
+
expect(buttons).toHaveLength(16)
|
| 148 |
+
})
|
| 149 |
+
})
|
web/src/__tests__/lib/api-self.spec.ts
CHANGED
|
@@ -72,6 +72,9 @@ describe('selfApi', () => {
|
|
| 72 |
logo_label_style: 't',
|
| 73 |
backdrop_label_style: 't',
|
| 74 |
poster_badge_direction: 'd',
|
|
|
|
|
|
|
|
|
|
| 75 |
})
|
| 76 |
|
| 77 |
const [url, options] = fetchMock.mock.calls[0]
|
|
@@ -94,6 +97,9 @@ describe('selfApi', () => {
|
|
| 94 |
logo_label_style: 't',
|
| 95 |
backdrop_label_style: 't',
|
| 96 |
poster_badge_direction: 'd',
|
|
|
|
|
|
|
|
|
|
| 97 |
})
|
| 98 |
})
|
| 99 |
|
|
@@ -130,14 +136,14 @@ describe('selfApi', () => {
|
|
| 130 |
expect(options.credentials).toBeUndefined()
|
| 131 |
})
|
| 132 |
|
| 133 |
-
it('previewPoster includes
|
| 134 |
const fetchMock = vi.fn().mockResolvedValue(makeFetchResponse(200))
|
| 135 |
vi.stubGlobal('fetch', fetchMock)
|
| 136 |
|
| 137 |
await selfApi.previewPoster(3, 'imdb,rt', 'r')
|
| 138 |
|
| 139 |
const [url] = fetchMock.mock.calls[0]
|
| 140 |
-
expect(url).toContain('
|
| 141 |
})
|
| 142 |
|
| 143 |
it('previewPoster includes label_style when provided', async () => {
|
|
|
|
| 72 |
logo_label_style: 't',
|
| 73 |
backdrop_label_style: 't',
|
| 74 |
poster_badge_direction: 'd',
|
| 75 |
+
poster_badge_size: 'l',
|
| 76 |
+
logo_badge_size: 's',
|
| 77 |
+
backdrop_badge_size: 'xl',
|
| 78 |
})
|
| 79 |
|
| 80 |
const [url, options] = fetchMock.mock.calls[0]
|
|
|
|
| 97 |
logo_label_style: 't',
|
| 98 |
backdrop_label_style: 't',
|
| 99 |
poster_badge_direction: 'd',
|
| 100 |
+
poster_badge_size: 'l',
|
| 101 |
+
logo_badge_size: 's',
|
| 102 |
+
backdrop_badge_size: 'xl',
|
| 103 |
})
|
| 104 |
})
|
| 105 |
|
|
|
|
| 136 |
expect(options.credentials).toBeUndefined()
|
| 137 |
})
|
| 138 |
|
| 139 |
+
it('previewPoster includes position when provided', async () => {
|
| 140 |
const fetchMock = vi.fn().mockResolvedValue(makeFetchResponse(200))
|
| 141 |
vi.stubGlobal('fetch', fetchMock)
|
| 142 |
|
| 143 |
await selfApi.previewPoster(3, 'imdb,rt', 'r')
|
| 144 |
|
| 145 |
const [url] = fetchMock.mock.calls[0]
|
| 146 |
+
expect(url).toContain('position=r')
|
| 147 |
})
|
| 148 |
|
| 149 |
it('previewPoster includes label_style when provided', async () => {
|
web/src/__tests__/lib/api.spec.ts
CHANGED
|
@@ -204,24 +204,24 @@ describe('api', () => {
|
|
| 204 |
expect(url).toContain('ratings_order=imdb%2Crt%2Ctmdb')
|
| 205 |
})
|
| 206 |
|
| 207 |
-
it('adminApi.previewPoster includes
|
| 208 |
const fetchMock = vi.fn().mockResolvedValue(makeFetchResponse(200))
|
| 209 |
vi.stubGlobal('fetch', fetchMock)
|
| 210 |
|
| 211 |
await adminApi.previewPoster(3, 'imdb,rt', 'l')
|
| 212 |
|
| 213 |
const [url] = fetchMock.mock.calls[0]
|
| 214 |
-
expect(url).toContain('
|
| 215 |
})
|
| 216 |
|
| 217 |
-
it('adminApi.previewPoster omits
|
| 218 |
const fetchMock = vi.fn().mockResolvedValue(makeFetchResponse(200))
|
| 219 |
vi.stubGlobal('fetch', fetchMock)
|
| 220 |
|
| 221 |
await adminApi.previewPoster(3, 'imdb,rt')
|
| 222 |
|
| 223 |
const [url] = fetchMock.mock.calls[0]
|
| 224 |
-
expect(url).not.toContain('
|
| 225 |
})
|
| 226 |
|
| 227 |
it('adminApi.previewPoster includes label_style when provided', async () => {
|
|
|
|
| 204 |
expect(url).toContain('ratings_order=imdb%2Crt%2Ctmdb')
|
| 205 |
})
|
| 206 |
|
| 207 |
+
it('adminApi.previewPoster includes position when provided', async () => {
|
| 208 |
const fetchMock = vi.fn().mockResolvedValue(makeFetchResponse(200))
|
| 209 |
vi.stubGlobal('fetch', fetchMock)
|
| 210 |
|
| 211 |
await adminApi.previewPoster(3, 'imdb,rt', 'l')
|
| 212 |
|
| 213 |
const [url] = fetchMock.mock.calls[0]
|
| 214 |
+
expect(url).toContain('position=l')
|
| 215 |
})
|
| 216 |
|
| 217 |
+
it('adminApi.previewPoster omits position when not provided', async () => {
|
| 218 |
const fetchMock = vi.fn().mockResolvedValue(makeFetchResponse(200))
|
| 219 |
vi.stubGlobal('fetch', fetchMock)
|
| 220 |
|
| 221 |
await adminApi.previewPoster(3, 'imdb,rt')
|
| 222 |
|
| 223 |
const [url] = fetchMock.mock.calls[0]
|
| 224 |
+
expect(url).not.toContain('position')
|
| 225 |
})
|
| 226 |
|
| 227 |
it('adminApi.previewPoster includes label_style when provided', async () => {
|
web/src/__tests__/lib/constants.spec.ts
ADDED
|
@@ -0,0 +1,68 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
import { describe, it, expect } from 'vitest'
|
| 2 |
+
import { ALL_RATING_SOURCES, DEFAULT_RATINGS_ORDER, parseRatingsOrder } from '@/lib/constants'
|
| 3 |
+
|
| 4 |
+
describe('ALL_RATING_SOURCES', () => {
|
| 5 |
+
it('has 8 rating sources', () => {
|
| 6 |
+
expect(ALL_RATING_SOURCES).toHaveLength(8)
|
| 7 |
+
})
|
| 8 |
+
|
| 9 |
+
it('each source has key, label, and color', () => {
|
| 10 |
+
for (const source of ALL_RATING_SOURCES) {
|
| 11 |
+
expect(source.key).toBeTruthy()
|
| 12 |
+
expect(source.label).toBeTruthy()
|
| 13 |
+
expect(source.color).toMatch(/^#[0-9a-f]{6}$/i)
|
| 14 |
+
}
|
| 15 |
+
})
|
| 16 |
+
|
| 17 |
+
it('keys are unique', () => {
|
| 18 |
+
const keys = ALL_RATING_SOURCES.map(s => s.key)
|
| 19 |
+
expect(new Set(keys).size).toBe(keys.length)
|
| 20 |
+
})
|
| 21 |
+
})
|
| 22 |
+
|
| 23 |
+
describe('parseRatingsOrder', () => {
|
| 24 |
+
it('returns keys in given order followed by missing keys', () => {
|
| 25 |
+
const result = parseRatingsOrder('imdb,tmdb')
|
| 26 |
+
expect(result[0]).toBe('imdb')
|
| 27 |
+
expect(result[1]).toBe('tmdb')
|
| 28 |
+
// All 8 keys should be present
|
| 29 |
+
expect(result).toHaveLength(8)
|
| 30 |
+
})
|
| 31 |
+
|
| 32 |
+
it('appends missing keys for partial input', () => {
|
| 33 |
+
const result = parseRatingsOrder('rt')
|
| 34 |
+
expect(result[0]).toBe('rt')
|
| 35 |
+
// All other keys should follow
|
| 36 |
+
const allKeys = ALL_RATING_SOURCES.map(s => s.key)
|
| 37 |
+
for (const key of allKeys) {
|
| 38 |
+
expect(result).toContain(key)
|
| 39 |
+
}
|
| 40 |
+
})
|
| 41 |
+
|
| 42 |
+
it('handles empty string by returning all keys', () => {
|
| 43 |
+
const result = parseRatingsOrder('')
|
| 44 |
+
const allKeys = ALL_RATING_SOURCES.map(s => s.key)
|
| 45 |
+
expect(result).toHaveLength(allKeys.length)
|
| 46 |
+
for (const key of allKeys) {
|
| 47 |
+
expect(result).toContain(key)
|
| 48 |
+
}
|
| 49 |
+
})
|
| 50 |
+
|
| 51 |
+
it('preserves the full default order', () => {
|
| 52 |
+
const result = parseRatingsOrder(DEFAULT_RATINGS_ORDER)
|
| 53 |
+
expect(result).toEqual(DEFAULT_RATINGS_ORDER.split(','))
|
| 54 |
+
})
|
| 55 |
+
|
| 56 |
+
it('trims whitespace around keys', () => {
|
| 57 |
+
const result = parseRatingsOrder('imdb , tmdb')
|
| 58 |
+
expect(result[0]).toBe('imdb')
|
| 59 |
+
expect(result[1]).toBe('tmdb')
|
| 60 |
+
})
|
| 61 |
+
|
| 62 |
+
it('does not include a key twice when already present in input', () => {
|
| 63 |
+
// parseRatingsOrder appends missing keys — keys already in the input should not be appended again
|
| 64 |
+
const result = parseRatingsOrder('imdb,tmdb')
|
| 65 |
+
const imdbCount = result.filter((k: string) => k === 'imdb').length
|
| 66 |
+
expect(imdbCount).toBe(1)
|
| 67 |
+
})
|
| 68 |
+
})
|
web/src/components/FreeApiKeyCard.vue
CHANGED
|
@@ -1,7 +1,8 @@
|
|
| 1 |
<script setup lang="ts">
|
| 2 |
import { ref, computed, watch, onUnmounted } from 'vue'
|
| 3 |
import { useAuthStore } from '@/stores/auth'
|
| 4 |
-
import { FREE_API_KEY, LANGUAGES } from '@/lib/constants'
|
|
|
|
| 5 |
import { Button } from '@/components/ui/button'
|
| 6 |
import { Input } from '@/components/ui/input'
|
| 7 |
import {
|
|
@@ -23,6 +24,16 @@ const imageType = ref<'poster' | 'logo' | 'backdrop'>('poster')
|
|
| 23 |
const idValue = ref('tt0013442')
|
| 24 |
const lang = ref('any')
|
| 25 |
const imageSize = ref<'default' | 'small' | 'medium' | 'large' | 'verylarge'>('default')
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 26 |
const fetchError = ref('')
|
| 27 |
const fetchLoading = ref(false)
|
| 28 |
const resultUrl = ref('')
|
|
@@ -45,12 +56,24 @@ const sizeOptions = computed(() => {
|
|
| 45 |
]
|
| 46 |
})
|
| 47 |
|
| 48 |
-
|
| 49 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 50 |
const validValues = sizeOptions.value.map(o => o.value)
|
| 51 |
if (!validValues.includes(imageSize.value)) {
|
| 52 |
imageSize.value = 'default'
|
| 53 |
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 54 |
})
|
| 55 |
|
| 56 |
const apiBase = import.meta.env.VITE_API_URL || ''
|
|
@@ -71,6 +94,15 @@ const queryString = computed(() => {
|
|
| 71 |
if (langVal.trim()) params.set('lang', langVal.trim())
|
| 72 |
const sizeVal = imageSize.value === 'default' ? '' : imageSize.value
|
| 73 |
if (sizeVal) params.set('imageSize', sizeVal)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 74 |
const qs = params.toString()
|
| 75 |
return qs ? `?${qs}` : ''
|
| 76 |
})
|
|
@@ -131,38 +163,8 @@ async function handleFetch() {
|
|
| 131 |
</button>
|
| 132 |
</CollapsibleTrigger>
|
| 133 |
<CollapsibleContent class="pt-3 space-y-3">
|
| 134 |
-
<form class="flex flex-col gap-
|
| 135 |
-
<div class="
|
| 136 |
-
<Select v-model="idType">
|
| 137 |
-
<SelectTrigger id="free-id-type" aria-label="ID type" class="bg-background">
|
| 138 |
-
<SelectValue placeholder="ID type" />
|
| 139 |
-
</SelectTrigger>
|
| 140 |
-
<SelectContent>
|
| 141 |
-
<SelectItem value="imdb">IMDb</SelectItem>
|
| 142 |
-
<SelectItem value="tmdb">TMDb</SelectItem>
|
| 143 |
-
<SelectItem value="tvdb">TVDB</SelectItem>
|
| 144 |
-
</SelectContent>
|
| 145 |
-
</Select>
|
| 146 |
-
<Select v-model="imageType">
|
| 147 |
-
<SelectTrigger id="free-image-type" aria-label="Image type" class="bg-background">
|
| 148 |
-
<SelectValue placeholder="Image type" />
|
| 149 |
-
</SelectTrigger>
|
| 150 |
-
<SelectContent>
|
| 151 |
-
<SelectItem value="poster">Poster</SelectItem>
|
| 152 |
-
<SelectItem value="logo">Logo</SelectItem>
|
| 153 |
-
<SelectItem value="backdrop">Backdrop</SelectItem>
|
| 154 |
-
</SelectContent>
|
| 155 |
-
</Select>
|
| 156 |
-
<Input
|
| 157 |
-
id="free-id-value"
|
| 158 |
-
v-model="idValue"
|
| 159 |
-
type="text"
|
| 160 |
-
:placeholder="idPlaceholder"
|
| 161 |
-
required
|
| 162 |
-
class="flex-1 min-w-0 font-mono bg-background"
|
| 163 |
-
/>
|
| 164 |
-
</div>
|
| 165 |
-
<div class="flex flex-col sm:flex-row gap-2 items-start sm:items-center">
|
| 166 |
<Select v-model="imageSize">
|
| 167 |
<SelectTrigger id="free-image-size" aria-label="Image size" class="bg-background">
|
| 168 |
<SelectValue placeholder="Size: default" />
|
|
@@ -184,13 +186,141 @@ async function handleFetch() {
|
|
| 184 |
</SelectItem>
|
| 185 |
</SelectContent>
|
| 186 |
</Select>
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 187 |
</div>
|
| 188 |
<code class="block text-xs font-mono bg-muted px-3 py-2 rounded text-muted-foreground break-all select-all">{{ curlExample }}</code>
|
| 189 |
-
<div class="flex
|
| 190 |
-
<
|
| 191 |
-
<
|
| 192 |
-
|
| 193 |
-
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 194 |
</div>
|
| 195 |
</form>
|
| 196 |
<p v-if="fetchError" class="text-sm text-destructive">{{ fetchError }}</p>
|
|
|
|
| 1 |
<script setup lang="ts">
|
| 2 |
import { ref, computed, watch, onUnmounted } from 'vue'
|
| 3 |
import { useAuthStore } from '@/stores/auth'
|
| 4 |
+
import { FREE_API_KEY, LANGUAGES, DEFAULT_RATINGS_ORDER, parseRatingsOrder } from '@/lib/constants'
|
| 5 |
+
import RatingsOrderList from '@/components/RatingsOrderList.vue'
|
| 6 |
import { Button } from '@/components/ui/button'
|
| 7 |
import { Input } from '@/components/ui/input'
|
| 8 |
import {
|
|
|
|
| 24 |
const idValue = ref('tt0013442')
|
| 25 |
const lang = ref('any')
|
| 26 |
const imageSize = ref<'default' | 'small' | 'medium' | 'large' | 'verylarge'>('default')
|
| 27 |
+
const badgeStyle = ref('default')
|
| 28 |
+
const labelStyle = ref('default')
|
| 29 |
+
const badgeSize = ref('default')
|
| 30 |
+
const ratingsLimit = ref('default')
|
| 31 |
+
const badgeDirection = ref('default')
|
| 32 |
+
const posterPosition = ref('default')
|
| 33 |
+
const posterSource = ref('default')
|
| 34 |
+
const fanartTextless = ref('default')
|
| 35 |
+
const ratingsOrderList = ref<string[]>(parseRatingsOrder(DEFAULT_RATINGS_ORDER))
|
| 36 |
+
const ratingsOrderChanged = ref(false)
|
| 37 |
const fetchError = ref('')
|
| 38 |
const fetchLoading = ref(false)
|
| 39 |
const resultUrl = ref('')
|
|
|
|
| 56 |
]
|
| 57 |
})
|
| 58 |
|
| 59 |
+
watch(ratingsOrderList, (newOrder) => {
|
| 60 |
+
const defaultOrder = parseRatingsOrder(DEFAULT_RATINGS_ORDER)
|
| 61 |
+
ratingsOrderChanged.value = newOrder.join(',') !== defaultOrder.join(',')
|
| 62 |
+
}, { deep: true })
|
| 63 |
+
|
| 64 |
+
// Reset size when switching image type if the current size is invalid,
|
| 65 |
+
// and reset poster-only controls when switching away from poster
|
| 66 |
+
watch(imageType, (newType) => {
|
| 67 |
const validValues = sizeOptions.value.map(o => o.value)
|
| 68 |
if (!validValues.includes(imageSize.value)) {
|
| 69 |
imageSize.value = 'default'
|
| 70 |
}
|
| 71 |
+
if (newType !== 'poster') {
|
| 72 |
+
badgeDirection.value = 'default'
|
| 73 |
+
posterPosition.value = 'default'
|
| 74 |
+
posterSource.value = 'default'
|
| 75 |
+
fanartTextless.value = 'default'
|
| 76 |
+
}
|
| 77 |
})
|
| 78 |
|
| 79 |
const apiBase = import.meta.env.VITE_API_URL || ''
|
|
|
|
| 94 |
if (langVal.trim()) params.set('lang', langVal.trim())
|
| 95 |
const sizeVal = imageSize.value === 'default' ? '' : imageSize.value
|
| 96 |
if (sizeVal) params.set('imageSize', sizeVal)
|
| 97 |
+
if (ratingsOrderChanged.value) params.set('ratings_order', ratingsOrderList.value.join(','))
|
| 98 |
+
if (badgeStyle.value !== 'default') params.set('badge_style', badgeStyle.value)
|
| 99 |
+
if (labelStyle.value !== 'default') params.set('label_style', labelStyle.value)
|
| 100 |
+
if (badgeSize.value !== 'default') params.set('badge_size', badgeSize.value)
|
| 101 |
+
if (ratingsLimit.value !== 'default') params.set('ratings_limit', ratingsLimit.value)
|
| 102 |
+
if (imageType.value === 'poster' && badgeDirection.value !== 'default') params.set('badge_direction', badgeDirection.value)
|
| 103 |
+
if (imageType.value === 'poster' && posterPosition.value !== 'default') params.set('position', posterPosition.value)
|
| 104 |
+
if (imageType.value === 'poster' && posterSource.value !== 'default') params.set('poster_source', posterSource.value)
|
| 105 |
+
if (imageType.value === 'poster' && fanartTextless.value !== 'default') params.set('fanart_textless', fanartTextless.value)
|
| 106 |
const qs = params.toString()
|
| 107 |
return qs ? `?${qs}` : ''
|
| 108 |
})
|
|
|
|
| 163 |
</button>
|
| 164 |
</CollapsibleTrigger>
|
| 165 |
<CollapsibleContent class="pt-3 space-y-3">
|
| 166 |
+
<form class="flex flex-col gap-3" @submit.prevent="handleFetch">
|
| 167 |
+
<div class="grid grid-cols-1 sm:grid-cols-2 gap-2">
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 168 |
<Select v-model="imageSize">
|
| 169 |
<SelectTrigger id="free-image-size" aria-label="Image size" class="bg-background">
|
| 170 |
<SelectValue placeholder="Size: default" />
|
|
|
|
| 186 |
</SelectItem>
|
| 187 |
</SelectContent>
|
| 188 |
</Select>
|
| 189 |
+
<Select v-model="ratingsLimit">
|
| 190 |
+
<SelectTrigger id="free-ratings-limit" aria-label="Ratings limit" class="bg-background">
|
| 191 |
+
<SelectValue placeholder="Max badges: default" />
|
| 192 |
+
</SelectTrigger>
|
| 193 |
+
<SelectContent>
|
| 194 |
+
<SelectItem value="default">Max badges: default</SelectItem>
|
| 195 |
+
<SelectItem v-for="n in 9" :key="n - 1" :value="String(n - 1)">
|
| 196 |
+
{{ n - 1 }} {{ n - 1 === 1 ? 'badge' : 'badges' }}
|
| 197 |
+
</SelectItem>
|
| 198 |
+
</SelectContent>
|
| 199 |
+
</Select>
|
| 200 |
+
<Select v-model="badgeStyle">
|
| 201 |
+
<SelectTrigger id="free-badge-style" aria-label="Badge style" class="bg-background">
|
| 202 |
+
<SelectValue placeholder="Badge style: default" />
|
| 203 |
+
</SelectTrigger>
|
| 204 |
+
<SelectContent>
|
| 205 |
+
<SelectItem value="default">Badge style: default</SelectItem>
|
| 206 |
+
<SelectItem value="h">Horizontal</SelectItem>
|
| 207 |
+
<SelectItem value="v">Vertical</SelectItem>
|
| 208 |
+
</SelectContent>
|
| 209 |
+
</Select>
|
| 210 |
+
<Select v-model="labelStyle">
|
| 211 |
+
<SelectTrigger id="free-label-style" aria-label="Label style" class="bg-background">
|
| 212 |
+
<SelectValue placeholder="Label style: default" />
|
| 213 |
+
</SelectTrigger>
|
| 214 |
+
<SelectContent>
|
| 215 |
+
<SelectItem value="default">Label style: default</SelectItem>
|
| 216 |
+
<SelectItem value="t">Text</SelectItem>
|
| 217 |
+
<SelectItem value="i">Icon</SelectItem>
|
| 218 |
+
<SelectItem value="o">Official</SelectItem>
|
| 219 |
+
</SelectContent>
|
| 220 |
+
</Select>
|
| 221 |
+
<Select v-model="badgeSize">
|
| 222 |
+
<SelectTrigger id="free-badge-size" aria-label="Badge size" class="bg-background">
|
| 223 |
+
<SelectValue placeholder="Badge size: default" />
|
| 224 |
+
</SelectTrigger>
|
| 225 |
+
<SelectContent>
|
| 226 |
+
<SelectItem value="default">Badge size: default</SelectItem>
|
| 227 |
+
<SelectItem value="xs">Extra Small</SelectItem>
|
| 228 |
+
<SelectItem value="s">Small</SelectItem>
|
| 229 |
+
<SelectItem value="m">Medium</SelectItem>
|
| 230 |
+
<SelectItem value="l">Large</SelectItem>
|
| 231 |
+
<SelectItem value="xl">Extra Large</SelectItem>
|
| 232 |
+
</SelectContent>
|
| 233 |
+
</Select>
|
| 234 |
+
<template v-if="imageType === 'poster'">
|
| 235 |
+
<Select v-model="posterPosition">
|
| 236 |
+
<SelectTrigger id="free-poster-position" aria-label="Position" class="bg-background">
|
| 237 |
+
<SelectValue placeholder="Position: default" />
|
| 238 |
+
</SelectTrigger>
|
| 239 |
+
<SelectContent>
|
| 240 |
+
<SelectItem value="default">Position: default</SelectItem>
|
| 241 |
+
<SelectItem value="bc">Bottom Center</SelectItem>
|
| 242 |
+
<SelectItem value="tc">Top Center</SelectItem>
|
| 243 |
+
<SelectItem value="l">Left</SelectItem>
|
| 244 |
+
<SelectItem value="r">Right</SelectItem>
|
| 245 |
+
<SelectItem value="tl">Top Left</SelectItem>
|
| 246 |
+
<SelectItem value="tr">Top Right</SelectItem>
|
| 247 |
+
<SelectItem value="bl">Bottom Left</SelectItem>
|
| 248 |
+
<SelectItem value="br">Bottom Right</SelectItem>
|
| 249 |
+
</SelectContent>
|
| 250 |
+
</Select>
|
| 251 |
+
<Select v-model="badgeDirection">
|
| 252 |
+
<SelectTrigger id="free-badge-direction" aria-label="Badge direction" class="bg-background">
|
| 253 |
+
<SelectValue placeholder="Direction: default" />
|
| 254 |
+
</SelectTrigger>
|
| 255 |
+
<SelectContent>
|
| 256 |
+
<SelectItem value="default">Direction: default</SelectItem>
|
| 257 |
+
<SelectItem value="d">Auto</SelectItem>
|
| 258 |
+
<SelectItem value="h">Horizontal</SelectItem>
|
| 259 |
+
<SelectItem value="v">Vertical</SelectItem>
|
| 260 |
+
</SelectContent>
|
| 261 |
+
</Select>
|
| 262 |
+
<Select v-model="posterSource">
|
| 263 |
+
<SelectTrigger id="free-poster-source" aria-label="Poster source" class="bg-background">
|
| 264 |
+
<SelectValue placeholder="Source: default" />
|
| 265 |
+
</SelectTrigger>
|
| 266 |
+
<SelectContent>
|
| 267 |
+
<SelectItem value="default">Source: default</SelectItem>
|
| 268 |
+
<SelectItem value="t">TMDB</SelectItem>
|
| 269 |
+
<SelectItem value="f">Fanart.tv</SelectItem>
|
| 270 |
+
</SelectContent>
|
| 271 |
+
</Select>
|
| 272 |
+
<Select v-model="fanartTextless">
|
| 273 |
+
<SelectTrigger id="free-fanart-textless" aria-label="Textless poster" class="bg-background">
|
| 274 |
+
<SelectValue placeholder="Textless: default" />
|
| 275 |
+
</SelectTrigger>
|
| 276 |
+
<SelectContent>
|
| 277 |
+
<SelectItem value="default">Textless: default</SelectItem>
|
| 278 |
+
<SelectItem value="true">Yes</SelectItem>
|
| 279 |
+
<SelectItem value="false">No</SelectItem>
|
| 280 |
+
</SelectContent>
|
| 281 |
+
</Select>
|
| 282 |
+
</template>
|
| 283 |
+
</div>
|
| 284 |
+
<div class="space-y-1 flex flex-col items-center">
|
| 285 |
+
<p class="text-xs text-muted-foreground">Rating priority</p>
|
| 286 |
+
<RatingsOrderList v-model="ratingsOrderList" compact />
|
| 287 |
</div>
|
| 288 |
<code class="block text-xs font-mono bg-muted px-3 py-2 rounded text-muted-foreground break-all select-all">{{ curlExample }}</code>
|
| 289 |
+
<div class="flex flex-wrap gap-2">
|
| 290 |
+
<Select v-model="idType">
|
| 291 |
+
<SelectTrigger id="free-id-type" aria-label="ID type" class="bg-background w-auto">
|
| 292 |
+
<SelectValue placeholder="ID type" />
|
| 293 |
+
</SelectTrigger>
|
| 294 |
+
<SelectContent>
|
| 295 |
+
<SelectItem value="imdb">IMDb</SelectItem>
|
| 296 |
+
<SelectItem value="tmdb">TMDb</SelectItem>
|
| 297 |
+
<SelectItem value="tvdb">TVDB</SelectItem>
|
| 298 |
+
</SelectContent>
|
| 299 |
+
</Select>
|
| 300 |
+
<Select v-model="imageType">
|
| 301 |
+
<SelectTrigger id="free-image-type" aria-label="Image type" class="bg-background w-auto">
|
| 302 |
+
<SelectValue placeholder="Image type" />
|
| 303 |
+
</SelectTrigger>
|
| 304 |
+
<SelectContent>
|
| 305 |
+
<SelectItem value="poster">Poster</SelectItem>
|
| 306 |
+
<SelectItem value="logo">Logo</SelectItem>
|
| 307 |
+
<SelectItem value="backdrop">Backdrop</SelectItem>
|
| 308 |
+
</SelectContent>
|
| 309 |
+
</Select>
|
| 310 |
+
<div class="flex gap-2 flex-1 min-w-[200px]">
|
| 311 |
+
<Input
|
| 312 |
+
id="free-id-value"
|
| 313 |
+
v-model="idValue"
|
| 314 |
+
type="text"
|
| 315 |
+
:placeholder="idPlaceholder"
|
| 316 |
+
required
|
| 317 |
+
class="flex-1 min-w-0 font-mono bg-background"
|
| 318 |
+
/>
|
| 319 |
+
<Button type="submit" :disabled="fetchLoading" class="shrink-0">
|
| 320 |
+
<Loader2 v-if="fetchLoading" class="h-4 w-4 animate-spin" />
|
| 321 |
+
<span v-else>Fetch</span>
|
| 322 |
+
</Button>
|
| 323 |
+
</div>
|
| 324 |
</div>
|
| 325 |
</form>
|
| 326 |
<p v-if="fetchError" class="text-sm text-destructive">{{ fetchError }}</p>
|
web/src/components/RatingsOrderList.vue
ADDED
|
@@ -0,0 +1,55 @@
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 1 |
+
<script setup lang="ts">
|
| 2 |
+
import { ALL_RATING_SOURCES } from '@/lib/constants'
|
| 3 |
+
|
| 4 |
+
const model = defineModel<string[]>({ required: true })
|
| 5 |
+
|
| 6 |
+
defineProps<{
|
| 7 |
+
compact?: boolean
|
| 8 |
+
}>()
|
| 9 |
+
|
| 10 |
+
function moveItem(from: number, to: number) {
|
| 11 |
+
if (to < 0 || to >= model.value.length) return
|
| 12 |
+
const arr = [...model.value]
|
| 13 |
+
const removed = arr.splice(from, 1)
|
| 14 |
+
arr.splice(to, 0, ...removed)
|
| 15 |
+
model.value = arr
|
| 16 |
+
}
|
| 17 |
+
|
| 18 |
+
function getRatingSource(key: string) {
|
| 19 |
+
return ALL_RATING_SOURCES.find(s => s.key === key)
|
| 20 |
+
}
|
| 21 |
+
</script>
|
| 22 |
+
|
| 23 |
+
<template>
|
| 24 |
+
<div :class="compact ? 'space-y-0.5' : 'space-y-1'" class="max-w-sm">
|
| 25 |
+
<div
|
| 26 |
+
v-for="(key, index) in model"
|
| 27 |
+
:key="key"
|
| 28 |
+
class="flex items-center gap-2 rounded border bg-background"
|
| 29 |
+
:class="compact ? 'px-1.5 py-1' : 'px-2 py-1.5'"
|
| 30 |
+
>
|
| 31 |
+
<span class="text-muted-foreground text-xs select-none w-4 text-right">{{ index + 1 }}</span>
|
| 32 |
+
<span
|
| 33 |
+
class="inline-block w-2.5 h-2.5 rounded-full shrink-0"
|
| 34 |
+
:style="{ backgroundColor: getRatingSource(key)?.color }"
|
| 35 |
+
></span>
|
| 36 |
+
<span class="text-sm flex-1">{{ getRatingSource(key)?.label || key }}</span>
|
| 37 |
+
<button
|
| 38 |
+
type="button"
|
| 39 |
+
class="inline-flex items-center justify-center rounded border text-muted-foreground hover:text-foreground hover:bg-muted disabled:opacity-30 disabled:pointer-events-none"
|
| 40 |
+
:class="compact ? 'w-6 h-6 text-xs' : 'w-8 h-8'"
|
| 41 |
+
:disabled="index === 0"
|
| 42 |
+
@click="moveItem(index, index - 1)"
|
| 43 |
+
title="Move up"
|
| 44 |
+
>↑</button>
|
| 45 |
+
<button
|
| 46 |
+
type="button"
|
| 47 |
+
class="inline-flex items-center justify-center rounded border text-muted-foreground hover:text-foreground hover:bg-muted disabled:opacity-30 disabled:pointer-events-none"
|
| 48 |
+
:class="compact ? 'w-6 h-6 text-xs' : 'w-8 h-8'"
|
| 49 |
+
:disabled="index === model.length - 1"
|
| 50 |
+
@click="moveItem(index, index + 1)"
|
| 51 |
+
title="Move down"
|
| 52 |
+
>↓</button>
|
| 53 |
+
</div>
|
| 54 |
+
</div>
|
| 55 |
+
</template>
|
web/src/components/RenderSettingsForm.vue
CHANGED
|
@@ -12,8 +12,9 @@ import {
|
|
| 12 |
SelectTrigger,
|
| 13 |
SelectValue,
|
| 14 |
} from '@/components/ui/select'
|
|
|
|
| 15 |
import type { SaveSettingsPayload } from '@/lib/api'
|
| 16 |
-
import { LANGUAGES } from '@/lib/constants'
|
| 17 |
|
| 18 |
export interface RenderSettings {
|
| 19 |
poster_source: string
|
|
@@ -38,17 +39,6 @@ export interface RenderSettings {
|
|
| 38 |
backdrop_badge_size: string
|
| 39 |
}
|
| 40 |
|
| 41 |
-
const ALL_RATING_SOURCES = [
|
| 42 |
-
{ key: 'imdb', label: 'IMDb', color: '#b4910f' },
|
| 43 |
-
{ key: 'tmdb', label: 'TMDB', color: '#019b58' },
|
| 44 |
-
{ key: 'rt', label: 'Rotten Tomatoes (Critics)', color: '#b92308' },
|
| 45 |
-
{ key: 'rta', label: 'Rotten Tomatoes (Audience)', color: '#b92308' },
|
| 46 |
-
{ key: 'mc', label: 'Metacritic', color: '#4b9626' },
|
| 47 |
-
{ key: 'trakt', label: 'Trakt', color: '#af0f2d' },
|
| 48 |
-
{ key: 'lb', label: 'Letterboxd', color: '#009b58' },
|
| 49 |
-
{ key: 'mal', label: 'MyAnimeList', color: '#223c78' },
|
| 50 |
-
] as const
|
| 51 |
-
|
| 52 |
const props = defineProps<{
|
| 53 |
settings: RenderSettings
|
| 54 |
uid?: string
|
|
@@ -65,7 +55,7 @@ const editLang = ref(props.settings.fanart_lang || 'en')
|
|
| 65 |
const editTextless = ref(props.settings.fanart_textless)
|
| 66 |
const editSource = computed(() => editFanart.value ? 'f' : 't')
|
| 67 |
const editRatingsLimit = ref(props.settings.ratings_limit)
|
| 68 |
-
const editRatingsOrder = ref<string[]>(
|
| 69 |
const editPosterPosition = ref(props.settings.poster_position || 'bc')
|
| 70 |
const editLogoRatingsLimit = ref(props.settings.logo_ratings_limit ?? 3)
|
| 71 |
const editBackdropRatingsLimit = ref(props.settings.backdrop_ratings_limit ?? 3)
|
|
@@ -85,7 +75,7 @@ function applySettings(s: RenderSettings) {
|
|
| 85 |
editLang.value = s.fanart_lang || 'en'
|
| 86 |
editTextless.value = s.fanart_textless
|
| 87 |
editRatingsLimit.value = s.ratings_limit
|
| 88 |
-
editRatingsOrder.value =
|
| 89 |
editPosterPosition.value = s.poster_position || 'bc'
|
| 90 |
editLogoRatingsLimit.value = s.logo_ratings_limit ?? 3
|
| 91 |
editBackdropRatingsLimit.value = s.backdrop_ratings_limit ?? 3
|
|
@@ -106,27 +96,6 @@ const error = ref('')
|
|
| 106 |
const showCheck = ref(false)
|
| 107 |
let checkTimeout: ReturnType<typeof setTimeout> | null = null
|
| 108 |
let syncing = false
|
| 109 |
-
function parseOrder(order: string): string[] {
|
| 110 |
-
const keys = order ? order.split(',').map(k => k.trim()).filter(Boolean) : []
|
| 111 |
-
// Ensure all sources are present — add any missing ones at the end
|
| 112 |
-
const allKeys = ALL_RATING_SOURCES.map(s => s.key)
|
| 113 |
-
for (const k of allKeys) {
|
| 114 |
-
if (!keys.includes(k)) keys.push(k)
|
| 115 |
-
}
|
| 116 |
-
return keys
|
| 117 |
-
}
|
| 118 |
-
|
| 119 |
-
function moveItem(from: number, to: number) {
|
| 120 |
-
if (to < 0 || to >= editRatingsOrder.value.length) return
|
| 121 |
-
const arr = [...editRatingsOrder.value]
|
| 122 |
-
const removed = arr.splice(from, 1)
|
| 123 |
-
arr.splice(to, 0, ...removed)
|
| 124 |
-
editRatingsOrder.value = arr
|
| 125 |
-
}
|
| 126 |
-
|
| 127 |
-
function getRatingSource(key: string) {
|
| 128 |
-
return ALL_RATING_SOURCES.find(s => s.key === key)
|
| 129 |
-
}
|
| 130 |
|
| 131 |
watch(() => props.settings, (s) => {
|
| 132 |
syncing = true
|
|
@@ -426,34 +395,7 @@ const inputId = (name: string) => props.uid ? `${name}-${props.uid}` : name
|
|
| 426 |
<div class="space-y-2">
|
| 427 |
<Label>Rating order</Label>
|
| 428 |
<p class="text-xs text-muted-foreground">Use the arrows to reorder. Higher items have priority.</p>
|
| 429 |
-
<
|
| 430 |
-
<div
|
| 431 |
-
v-for="(key, index) in editRatingsOrder"
|
| 432 |
-
:key="key"
|
| 433 |
-
class="flex items-center gap-2 rounded border px-2 py-1.5 bg-background"
|
| 434 |
-
>
|
| 435 |
-
<span class="text-muted-foreground text-xs select-none w-4 text-right">{{ index + 1 }}</span>
|
| 436 |
-
<span
|
| 437 |
-
class="inline-block w-2.5 h-2.5 rounded-full shrink-0"
|
| 438 |
-
:style="{ backgroundColor: getRatingSource(key)?.color }"
|
| 439 |
-
></span>
|
| 440 |
-
<span class="text-sm flex-1">{{ getRatingSource(key)?.label || key }}</span>
|
| 441 |
-
<button
|
| 442 |
-
type="button"
|
| 443 |
-
class="inline-flex items-center justify-center w-8 h-8 rounded border text-muted-foreground hover:text-foreground hover:bg-muted disabled:opacity-30 disabled:pointer-events-none"
|
| 444 |
-
:disabled="index === 0"
|
| 445 |
-
@click="moveItem(index, index - 1)"
|
| 446 |
-
title="Move up"
|
| 447 |
-
>↑</button>
|
| 448 |
-
<button
|
| 449 |
-
type="button"
|
| 450 |
-
class="inline-flex items-center justify-center w-8 h-8 rounded border text-muted-foreground hover:text-foreground hover:bg-muted disabled:opacity-30 disabled:pointer-events-none"
|
| 451 |
-
:disabled="index === editRatingsOrder.length - 1"
|
| 452 |
-
@click="moveItem(index, index + 1)"
|
| 453 |
-
title="Move down"
|
| 454 |
-
>↓</button>
|
| 455 |
-
</div>
|
| 456 |
-
</div>
|
| 457 |
</div>
|
| 458 |
</div>
|
| 459 |
|
|
|
|
| 12 |
SelectTrigger,
|
| 13 |
SelectValue,
|
| 14 |
} from '@/components/ui/select'
|
| 15 |
+
import RatingsOrderList from '@/components/RatingsOrderList.vue'
|
| 16 |
import type { SaveSettingsPayload } from '@/lib/api'
|
| 17 |
+
import { LANGUAGES, parseRatingsOrder } from '@/lib/constants'
|
| 18 |
|
| 19 |
export interface RenderSettings {
|
| 20 |
poster_source: string
|
|
|
|
| 39 |
backdrop_badge_size: string
|
| 40 |
}
|
| 41 |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 42 |
const props = defineProps<{
|
| 43 |
settings: RenderSettings
|
| 44 |
uid?: string
|
|
|
|
| 55 |
const editTextless = ref(props.settings.fanart_textless)
|
| 56 |
const editSource = computed(() => editFanart.value ? 'f' : 't')
|
| 57 |
const editRatingsLimit = ref(props.settings.ratings_limit)
|
| 58 |
+
const editRatingsOrder = ref<string[]>(parseRatingsOrder(props.settings.ratings_order))
|
| 59 |
const editPosterPosition = ref(props.settings.poster_position || 'bc')
|
| 60 |
const editLogoRatingsLimit = ref(props.settings.logo_ratings_limit ?? 3)
|
| 61 |
const editBackdropRatingsLimit = ref(props.settings.backdrop_ratings_limit ?? 3)
|
|
|
|
| 75 |
editLang.value = s.fanart_lang || 'en'
|
| 76 |
editTextless.value = s.fanart_textless
|
| 77 |
editRatingsLimit.value = s.ratings_limit
|
| 78 |
+
editRatingsOrder.value = parseRatingsOrder(s.ratings_order)
|
| 79 |
editPosterPosition.value = s.poster_position || 'bc'
|
| 80 |
editLogoRatingsLimit.value = s.logo_ratings_limit ?? 3
|
| 81 |
editBackdropRatingsLimit.value = s.backdrop_ratings_limit ?? 3
|
|
|
|
| 96 |
const showCheck = ref(false)
|
| 97 |
let checkTimeout: ReturnType<typeof setTimeout> | null = null
|
| 98 |
let syncing = false
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 99 |
|
| 100 |
watch(() => props.settings, (s) => {
|
| 101 |
syncing = true
|
|
|
|
| 395 |
<div class="space-y-2">
|
| 396 |
<Label>Rating order</Label>
|
| 397 |
<p class="text-xs text-muted-foreground">Use the arrows to reorder. Higher items have priority.</p>
|
| 398 |
+
<RatingsOrderList v-model="editRatingsOrder" />
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 399 |
</div>
|
| 400 |
</div>
|
| 401 |
|
web/src/lib/api.ts
CHANGED
|
@@ -122,7 +122,7 @@ export const adminApi = {
|
|
| 122 |
fetchBackdrop: (idType: string, idValue: string): Promise<Response> =>
|
| 123 |
post(`/api/admin/backdrops/${idType}/${idValue}/fetch`),
|
| 124 |
previewPoster: (ratingsLimit: number, ratingsOrder: string, posterPosition?: string, badgeStyle?: string, labelStyle?: string, badgeDirection?: string, badgeSize?: string): Promise<Response> =>
|
| 125 |
-
get(buildUrl('/api/admin/preview/poster', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder,
|
| 126 |
previewLogo: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string): Promise<Response> =>
|
| 127 |
get(buildUrl('/api/admin/preview/logo', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize })),
|
| 128 |
previewBackdrop: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string): Promise<Response> =>
|
|
@@ -159,7 +159,7 @@ export const selfApi = {
|
|
| 159 |
resetSettings: (): Promise<Response> =>
|
| 160 |
keyRequest('/api/key/me/settings', { method: 'DELETE' }),
|
| 161 |
previewPoster: (ratingsLimit: number, ratingsOrder: string, posterPosition?: string, badgeStyle?: string, labelStyle?: string, badgeDirection?: string, badgeSize?: string): Promise<Response> =>
|
| 162 |
-
keyRequest(buildUrl('/api/key/me/preview/poster', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder,
|
| 163 |
previewLogo: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string): Promise<Response> =>
|
| 164 |
keyRequest(buildUrl('/api/key/me/preview/logo', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize })),
|
| 165 |
previewBackdrop: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string): Promise<Response> =>
|
|
|
|
| 122 |
fetchBackdrop: (idType: string, idValue: string): Promise<Response> =>
|
| 123 |
post(`/api/admin/backdrops/${idType}/${idValue}/fetch`),
|
| 124 |
previewPoster: (ratingsLimit: number, ratingsOrder: string, posterPosition?: string, badgeStyle?: string, labelStyle?: string, badgeDirection?: string, badgeSize?: string): Promise<Response> =>
|
| 125 |
+
get(buildUrl('/api/admin/preview/poster', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, position: posterPosition, badge_style: badgeStyle, label_style: labelStyle, badge_direction: badgeDirection, badge_size: badgeSize })),
|
| 126 |
previewLogo: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string): Promise<Response> =>
|
| 127 |
get(buildUrl('/api/admin/preview/logo', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize })),
|
| 128 |
previewBackdrop: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string): Promise<Response> =>
|
|
|
|
| 159 |
resetSettings: (): Promise<Response> =>
|
| 160 |
keyRequest('/api/key/me/settings', { method: 'DELETE' }),
|
| 161 |
previewPoster: (ratingsLimit: number, ratingsOrder: string, posterPosition?: string, badgeStyle?: string, labelStyle?: string, badgeDirection?: string, badgeSize?: string): Promise<Response> =>
|
| 162 |
+
keyRequest(buildUrl('/api/key/me/preview/poster', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, position: posterPosition, badge_style: badgeStyle, label_style: labelStyle, badge_direction: badgeDirection, badge_size: badgeSize })),
|
| 163 |
previewLogo: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string): Promise<Response> =>
|
| 164 |
keyRequest(buildUrl('/api/key/me/preview/logo', { ratings_limit: ratingsLimit, ratings_order: ratingsOrder, badge_style: badgeStyle, label_style: labelStyle, badge_size: badgeSize })),
|
| 165 |
previewBackdrop: (ratingsLimit: number, ratingsOrder: string, badgeStyle?: string, labelStyle?: string, badgeSize?: string): Promise<Response> =>
|
web/src/lib/constants.ts
CHANGED
|
@@ -38,3 +38,25 @@ export const LANGUAGES = [
|
|
| 38 |
{ code: 'uk', name: 'Ukrainian' },
|
| 39 |
{ code: 'vi', name: 'Vietnamese' },
|
| 40 |
] as const
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| 38 |
{ code: 'uk', name: 'Ukrainian' },
|
| 39 |
{ code: 'vi', name: 'Vietnamese' },
|
| 40 |
] as const
|
| 41 |
+
|
| 42 |
+
export const ALL_RATING_SOURCES = [
|
| 43 |
+
{ key: 'imdb', label: 'IMDb', color: '#b4910f' },
|
| 44 |
+
{ key: 'tmdb', label: 'TMDB', color: '#019b58' },
|
| 45 |
+
{ key: 'rt', label: 'Rotten Tomatoes (Critics)', color: '#b92308' },
|
| 46 |
+
{ key: 'rta', label: 'Rotten Tomatoes (Audience)', color: '#b92308' },
|
| 47 |
+
{ key: 'mc', label: 'Metacritic', color: '#4b9626' },
|
| 48 |
+
{ key: 'trakt', label: 'Trakt', color: '#af0f2d' },
|
| 49 |
+
{ key: 'lb', label: 'Letterboxd', color: '#009b58' },
|
| 50 |
+
{ key: 'mal', label: 'MyAnimeList', color: '#223c78' },
|
| 51 |
+
] as const
|
| 52 |
+
|
| 53 |
+
export const DEFAULT_RATINGS_ORDER = 'mal,imdb,lb,rt,mc,rta,tmdb,trakt'
|
| 54 |
+
|
| 55 |
+
export function parseRatingsOrder(order: string): string[] {
|
| 56 |
+
const keys = order ? order.split(',').map(k => k.trim()).filter(Boolean) : []
|
| 57 |
+
const allKeys = ALL_RATING_SOURCES.map(s => s.key)
|
| 58 |
+
for (const k of allKeys) {
|
| 59 |
+
if (!keys.includes(k)) keys.push(k)
|
| 60 |
+
}
|
| 61 |
+
return keys
|
| 62 |
+
}
|