PNRxA commited on
Commit
0b7bef2
·
1 Parent(s): dee5c19

expose all customisation through url params, fixes #3

Browse files
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
- | `poster_position` | `bc`, `tc`, `l`, `r`, `tl`, `tr`, `bl`, `br` | Bottom-center, Top-center, Left, Right, corners |
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, PosterPosition, PosterSource};
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: PosterPosition,
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: PosterPosition,
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, PosterPosition, PosterSource};
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: PosterPosition,
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: PosterPosition,
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::RenderSettings;
 
 
 
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 and override `fanart_lang` in settings.
170
- fn apply_lang_override(
 
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.lang_override = true;
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 apply_lang_override(settings, &query.lang) {
 
 
 
 
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, BadgeSize, BadgeStyle, LabelStyle, PosterPosition};
 
 
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
- #[derive(Debug, Deserialize)]
89
- pub struct PreviewQuery {
90
- #[serde(default = "default_ratings_limit")]
91
- pub ratings_limit: i32,
92
- #[serde(default)]
93
- pub ratings_order: String,
94
- #[serde(default)]
95
- pub poster_position: Option<PosterPosition>,
96
- #[serde(default)]
97
- pub badge_style: Option<BadgeStyle>,
98
- #[serde(default = "db::default_label_style")]
99
- pub label_style: LabelStyle,
100
- #[serde(default = "db::default_poster_badge_direction")]
101
- pub badge_direction: BadgeDirection,
102
- #[serde(default = "db::default_badge_size")]
103
- pub badge_size: BadgeSize,
104
- #[serde(default, rename = "imageSize")]
105
- pub image_size: Option<String>,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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<PreviewQuery>,
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 position = query.poster_position.unwrap_or(PosterPosition::BottomCenter);
 
 
 
 
 
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 suffix = ratings::ratings_cache_suffix(&query.ratings_order, query.ratings_limit);
139
- let pos_suffix = serve::poster_position_cache_suffix(position.as_str());
140
- let bs_suffix = serve::badge_style_cache_suffix(badge_style.as_str());
141
- let ls_suffix = serve::label_style_cache_suffix(label_style.as_str());
142
- let bd_suffix = serve::badge_direction_cache_suffix(badge_direction.as_str());
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, &query.ratings_order, query.ratings_limit);
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<PreviewQuery>,
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 badge_style = query.badge_style.unwrap_or(BadgeStyle::Horizontal);
191
- let label_style = query.label_style;
192
- let suffix = ratings::ratings_cache_suffix(&query.ratings_order, query.ratings_limit);
193
- let bs_suffix = serve::badge_style_cache_suffix(badge_style.as_str());
194
- let ls_suffix = serve::label_style_cache_suffix(label_style.as_str());
195
- let bsz_suffix = badge_size.cache_suffix();
196
- let is_suffix = serve::image_size_cache_suffix(image_size);
197
- let cache_key = format!("preview-logo:{suffix}{bs_suffix}{ls_suffix}{bsz_suffix}{is_suffix}");
198
- let cache_path = cache::preview_path(&state.config.cache_dir, cache::ImageType::Logo, &format!("{suffix}{bs_suffix}{ls_suffix}{bsz_suffix}{is_suffix}"), "png")?;
 
 
 
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, &query.ratings_order, query.ratings_limit);
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<PreviewQuery>,
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 badge_style = query.badge_style.unwrap_or(BadgeStyle::Vertical);
240
- let label_style = query.label_style;
241
- let suffix = ratings::ratings_cache_suffix(&query.ratings_order, query.ratings_limit);
242
- let bs_suffix = serve::badge_style_cache_suffix(badge_style.as_str());
243
- let ls_suffix = serve::label_style_cache_suffix(label_style.as_str());
244
- let bsz_suffix = badge_size.cache_suffix();
245
- let is_suffix = serve::image_size_cache_suffix(image_size);
246
- let cache_key = format!("preview-backdrop:{suffix}{bs_suffix}{ls_suffix}{bsz_suffix}{is_suffix}");
247
- let cache_path = cache::preview_path(&state.config.cache_dir, cache::ImageType::Backdrop, &format!("{suffix}{bs_suffix}{ls_suffix}{bsz_suffix}{is_suffix}"), "jpg")?;
 
 
 
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, &query.ratings_order, query.ratings_limit);
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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium);
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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium);
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 default_ratings_limit_is_3() {
356
- assert_eq!(default_ratings_limit(), 3);
 
357
  }
358
 
359
  #[test]
360
- fn preview_query_defaults() {
361
  // Simulate what axum does with no query params — serde defaults apply
362
- let query: PreviewQuery = serde_json::from_str("{}").unwrap();
363
- assert_eq!(query.ratings_limit, 3);
364
- assert_eq!(query.ratings_order, "");
365
  assert_eq!(query.badge_style, None);
366
- assert_eq!(query.label_style, LabelStyle::Official);
367
- assert_eq!(query.badge_direction, BadgeDirection::Default);
368
  assert!(query.image_size.is_none());
369
  }
370
 
371
  #[test]
372
- fn preview_query_custom_values() {
373
- let query: PreviewQuery =
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, PosterPosition};
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: PosterPosition,
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: PosterPosition, 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,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: PosterPosition, 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,7 +242,7 @@ pub fn render_poster_sync(
242
  badges: &[RatingBadge],
243
  font: &FontArc,
244
  quality: u8,
245
- poster_position: PosterPosition,
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, PosterPosition::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,7 +621,7 @@ mod tests {
621
  },
622
  ];
623
 
624
- let result = render_poster_sync(&png_bytes, &badges, &font, 85, PosterPosition::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,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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium);
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, PosterPosition::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
  #[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, PosterPosition::Left, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
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, PosterPosition::Right, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Icon, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
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, PosterPosition::TopLeft, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
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, PosterPosition::BottomRight, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Vertical, 500, 1.0, BadgeSize::Medium).unwrap();
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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Official, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Medium).unwrap();
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: PosterPosition::BottomCenter,
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: PosterPosition::BottomCenter,
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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 1280, 2.2, BadgeSize::Medium).unwrap();
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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 1280, 2.2, BadgeSize::Medium).unwrap();
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, PosterPosition::BottomCenter, BadgeStyle::Horizontal, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::Large).unwrap();
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, PosterPosition::BottomCenter, BadgeStyle::Vertical, LabelStyle::Text, BadgeDirection::Horizontal, 500, 1.0, BadgeSize::ExtraLarge).unwrap();
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
- lang_override: _, // handled by code path, not suffix
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.lang_override { b"1" } else { b"0" });
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.lang_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,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 `?lang=` was provided, try the fanart
577
- // path first. On hit, return immediately.
578
  //
579
  // 2. On fanart miss, fall through to TMDB. The settings used for TMDB depend
580
  // on *why* we tried fanart:
581
- // a. `?lang=` on a TMDB user — preserve the user's original settings
582
- // (badge style, position, etc.) for the TMDB fallback; just clear
583
- // the lang_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,8 +591,8 @@ pub async fn handle_inner(
591
 
592
  // TMDB path (default, or fanart fallback)
593
  if use_fanart {
594
- if settings.lang_override && !settings.poster_source.is_fanart() {
595
- settings.lang_override = false;
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.lang_override {
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 settings_hash_includes_lang_override() {
1619
  let mut s1 = RenderSettings::default();
1620
  let mut s2 = RenderSettings::default();
1621
  s1.fanart_lang = "de".into();
1622
- s1.lang_override = false;
1623
  s2.fanart_lang = "de".into();
1624
- s2.lang_override = true;
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.lang_override = false;
1747
- s2.lang_override = true;
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: PosterPosition) -> Self {
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 = DIRECTION_DEFAULT;
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 PosterPosition {
227
  BottomCenter,
228
  TopCenter,
229
  Left,
@@ -234,7 +238,7 @@ pub enum PosterPosition {
234
  BottomRight,
235
  }
236
 
237
- impl PosterPosition {
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!(PosterPosition);
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() -> PosterPosition {
425
- PosterPosition::BottomCenter
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!(PosterPosition::parse("bc").is_ok());
785
- assert!(PosterPosition::parse("tc").is_ok());
786
- assert!(PosterPosition::parse("l").is_ok());
787
- assert!(PosterPosition::parse("r").is_ok());
788
- assert!(PosterPosition::parse("tl").is_ok());
789
- assert!(PosterPosition::parse("tr").is_ok());
790
- assert!(PosterPosition::parse("bl").is_ok());
791
- assert!(PosterPosition::parse("br").is_ok());
792
  }
793
 
794
  #[test]
795
  fn validate_poster_position_rejects_invalid() {
796
- assert!(PosterPosition::parse("center").is_err());
797
- assert!(PosterPosition::parse("").is_err());
798
- assert!(PosterPosition::parse("bottom-center").is_err());
799
- assert!(PosterPosition::parse("middle").is_err());
800
  }
801
 
802
  #[test]
803
  fn default_poster_position_returns_bottom_center() {
804
- assert_eq!(default_poster_position(), PosterPosition::BottomCenter);
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(PosterPosition::parse("bc").unwrap()), BadgeDirection::Horizontal);
881
- assert_eq!(BadgeDirection::parse("d").unwrap().resolve(PosterPosition::parse("tc").unwrap()), BadgeDirection::Horizontal);
882
  }
883
 
884
  #[test]
885
  fn resolve_badge_direction_default_side_positions() {
886
- assert_eq!(BadgeDirection::parse("d").unwrap().resolve(PosterPosition::parse("l").unwrap()), BadgeDirection::Vertical);
887
- assert_eq!(BadgeDirection::parse("d").unwrap().resolve(PosterPosition::parse("r").unwrap()), BadgeDirection::Vertical);
888
  }
889
 
890
  #[test]
891
  fn resolve_badge_direction_default_corner_positions() {
892
- assert_eq!(BadgeDirection::parse("d").unwrap().resolve(PosterPosition::parse("tl").unwrap()), BadgeDirection::Vertical);
893
- assert_eq!(BadgeDirection::parse("d").unwrap().resolve(PosterPosition::parse("tr").unwrap()), BadgeDirection::Vertical);
894
- assert_eq!(BadgeDirection::parse("d").unwrap().resolve(PosterPosition::parse("bl").unwrap()), BadgeDirection::Vertical);
895
- assert_eq!(BadgeDirection::parse("d").unwrap().resolve(PosterPosition::parse("br").unwrap()), BadgeDirection::Vertical);
896
  }
897
 
898
  #[test]
899
  fn resolve_badge_direction_explicit_passes_through() {
900
- assert_eq!(BadgeDirection::parse("h").unwrap().resolve(PosterPosition::parse("l").unwrap()), BadgeDirection::Horizontal);
901
- assert_eq!(BadgeDirection::parse("v").unwrap().resolve(PosterPosition::parse("bc").unwrap()), BadgeDirection::Vertical);
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: PosterPosition,
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=` query param overrides the stored fanart_lang at request time.
1480
  #[serde(skip)]
1481
- pub lang_override: bool,
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: PosterPosition::BottomCenter,
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
- lang_override: false,
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", PosterPosition::parse, defaults.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
- lang_override: false,
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", PosterPosition::parse, PosterPosition::BottomCenter),
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
- lang_override: false,
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::PosterPosition::BottomCenter);
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::PosterPosition::Right);
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?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,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&poster_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&poster_position=l", &token)).await.unwrap();
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?poster_position=invalid", &token)).await.unwrap();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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?poster_position=$pos" \
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
- * Find all Select stub component wrappers.
55
- * Order in FreeApiKeyCard template: idType, imageType, imageSize, lang
56
  */
57
- function findSelectComponents(wrapper: VueWrapper) {
58
- return wrapper.findAllComponents(SelectStub)
59
- }
60
-
61
- /** Set a Select stub's value by emitting update:modelValue directly. */
62
- async function setSelect(wrapper: VueWrapper, index: number, value: string) {
63
- const selects = findSelectComponents(wrapper)
64
- selects[index].vm.$emit('update:modelValue', value)
 
 
 
 
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 setSelect(wrapper, 1, 'logo') // imageType
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 setSelect(wrapper, 2, 'small') // imageSize = small
106
- // Now switch imageType to poster again (same value) — watch doesn't fire
107
- // Instead, switch imageType away and back to trigger the reset
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 setSelect(wrapper, 1, 'backdrop') // imageType = backdrop
113
- await setSelect(wrapper, 2, 'small') // imageSize = small
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 setSelect(wrapper, 1, 'backdrop')
122
  // Set size to small (valid for backdrop)
123
- await setSelect(wrapper, 2, 'small')
124
  expect(findCurlCode(wrapper).text()).toContain('imageSize=small')
125
 
126
  // Switch back to poster — "small" is invalid, should reset to default
127
- await setSelect(wrapper, 1, 'poster')
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
- // Set lang
184
- await setSelect(wrapper, 3, 'en')
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 setSelect(wrapper, 0, 'tmdb')
200
  expect(getPlaceholder()).toBe('movie-872585')
201
 
202
- await setSelect(wrapper, 0, 'tvdb')
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 poster_position when provided', async () => {
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('poster_position=r')
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 poster_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('poster_position=l')
215
  })
216
 
217
- it('adminApi.previewPoster omits poster_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('poster_position')
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
- // Reset size when switching image type if the current size is invalid
49
- watch(imageType, () => {
 
 
 
 
 
 
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-2" @submit.prevent="handleFetch">
135
- <div class="flex flex-col sm:flex-row gap-2">
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 justify-center">
190
- <Button type="submit" size="lg" :disabled="fetchLoading">
191
- <Loader2 v-if="fetchLoading" class="h-4 w-4 animate-spin" />
192
- <span v-else>Fetch</span>
193
- </Button>
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
+ >&uarr;</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
+ >&darr;</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[]>(parseOrder(props.settings.ratings_order))
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 = parseOrder(s.ratings_order)
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
- <div class="space-y-1 max-w-sm">
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
- >&uarr;</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
- >&darr;</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, poster_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,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, poster_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> =>
 
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
+ }