lookups

Author: neckaros

src/model/episodes.rs

@@ -105,6 +105,13 @@ pub struct EpisodeForUpdate {
     pub trakt_votes: Option<u64>,
 }
 
+fn should_retry_episode_lookup_with_enriched_ids(
+    original_ids: &RsIds,
+    enriched_ids: &RsIds,
+) -> bool {
+    enriched_ids.as_all_external_ids() != original_ids.as_all_external_ids()
+}
+
 impl ModelController {
     async fn lookup_episodes_metadata(
         &self,
@@ -214,9 +221,27 @@ impl ModelController {
                 query.serie_ref = Some(serie.item.id);
                 store.get_episodes(query).await?
             } else {
-                let episodes = self
+                let mut episodes = self
                     .lookup_episodes_metadata(library_id, &serie_id, &id, requesting_user)
                     .await?;
+                if episodes.is_empty() {
+                    if let Some(serie) = self
+                        .get_serie(library_id, serie_id.clone(), requesting_user)
+                        .await?
+                    {
+                        let enriched_ids: RsIds = serie.item.into();
+                        if should_retry_episode_lookup_with_enriched_ids(&id, &enriched_ids) {
+                            episodes = self
+                                .lookup_episodes_metadata(
+                                    library_id,
+                                    &serie_id,
+                                    &enriched_ids,
+                                    requesting_user,
+                                )
+                                .await?;
+                        }
+                    }
+                }
                 if episodes.is_empty() {
                     return Err(SourcesError::NotFound(Some(format!(
                         "get_episodes_by_id - Unable to find episodes for {:?}",
@@ -702,3 +727,32 @@ impl ModelController {
         .await
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::should_retry_episode_lookup_with_enriched_ids;
+    use rs_plugin_common_interfaces::domain::rs_ids::RsIds;
+
+    #[test]
+    fn enriched_episode_lookup_retries_when_new_external_ids_are_added() {
+        let original = RsIds::from_tmdb(203744);
+        let mut enriched = RsIds::from_tmdb(203744);
+        enriched.set("tvdb", 421070u64);
+
+        assert!(should_retry_episode_lookup_with_enriched_ids(
+            &original,
+            &enriched
+        ));
+    }
+
+    #[test]
+    fn enriched_episode_lookup_does_not_retry_when_external_ids_are_unchanged() {
+        let original = RsIds::from_tmdb(203744);
+        let enriched = RsIds::from_tmdb(203744);
+
+        assert!(!should_retry_episode_lookup_with_enriched_ids(
+            &original,
+            &enriched
+        ));
+    }
+}

src/model/series.rs

@@ -106,6 +106,33 @@ pub struct SerieForUpdate {
     pub max_created: Option<i64>,
 }
 
+enum ExternalSerieImageFallback {
+    ReturnRawError,
+    RetryWithResolvedLocalId(String),
+    RetryWithEnrichedLookup { name: String, ids: RsIds },
+}
+
+fn external_serie_image_fallback(
+    requested_id: &str,
+    requested_ids: RsIds,
+    resolved_serie: Option<ItemWithRelations<Serie>>,
+) -> ExternalSerieImageFallback {
+    let Some(serie) = resolved_serie else {
+        return ExternalSerieImageFallback::ReturnRawError;
+    };
+
+    if serie.item.id != requested_id && !RsIds::is_id(&serie.item.id) {
+        return ExternalSerieImageFallback::RetryWithResolvedLocalId(serie.item.id);
+    }
+
+    let name = serie.item.name.clone();
+
+    ExternalSerieImageFallback::RetryWithEnrichedLookup {
+        name,
+        ids: RsIds::from(serie.item),
+    }
+}
+
 impl SerieForUpdate {
     pub fn has_update(&self) -> bool {
         self != &SerieForUpdate::default()
@@ -800,20 +827,57 @@ impl ModelController {
                     )
                     .await;
             }
-            let lookup_query = RsLookupQuery::Serie(RsLookupSerie {
+            let raw_lookup_query = RsLookupQuery::Serie(RsLookupSerie {
                 name: None,
-                ids: Some(serie_ids),
+                ids: Some(serie_ids.clone()),
                 page_key: None,
             });
-            self.serve_cached_entity_image(
-                library_id,
-                serie_id,
-                lookup_query,
-                &kind,
-                &config,
-                requesting_user,
-            )
-            .await
+            let raw_result = self
+                .serve_cached_entity_image(
+                    library_id,
+                    serie_id,
+                    raw_lookup_query,
+                    &kind,
+                    &config,
+                    requesting_user,
+                )
+                .await;
+            if raw_result.is_ok() {
+                return raw_result;
+            }
+
+            let resolved_serie = self
+                .get_serie(library_id, serie_id.to_string(), requesting_user)
+                .await?;
+            match external_serie_image_fallback(serie_id, serie_ids, resolved_serie) {
+                ExternalSerieImageFallback::ReturnRawError => raw_result,
+                ExternalSerieImageFallback::RetryWithResolvedLocalId(local_id) => {
+                    self.serie_image(
+                        library_id,
+                        &local_id,
+                        Some(kind),
+                        size,
+                        requesting_user,
+                    )
+                    .await
+                }
+                ExternalSerieImageFallback::RetryWithEnrichedLookup { name, ids } => {
+                    let lookup_query = RsLookupQuery::Serie(RsLookupSerie {
+                        name: Some(name),
+                        ids: Some(ids),
+                        page_key: None,
+                    });
+                    self.serve_cached_entity_image(
+                        library_id,
+                        serie_id,
+                        lookup_query,
+                        &kind,
+                        &config,
+                        requesting_user,
+                    )
+                    .await
+                }
+            }
         } else {
             self.serve_local_entity_image(
                 library_id,
@@ -969,3 +1033,77 @@ impl ModelController {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::{external_serie_image_fallback, ExternalSerieImageFallback};
+    use crate::domain::serie::Serie;
+    use rs_plugin_common_interfaces::domain::{rs_ids::RsIds, ItemWithRelations};
+
+    #[test]
+    fn external_serie_image_fallback_returns_raw_error_when_resolution_fails() {
+        let fallback =
+            external_serie_image_fallback("tmdb:203744", RsIds::from_tmdb(203744), None);
+
+        assert!(matches!(
+            fallback,
+            ExternalSerieImageFallback::ReturnRawError
+        ));
+    }
+
+    #[test]
+    fn external_serie_image_fallback_retries_with_local_id_when_entity_exists_locally() {
+        let resolved = ItemWithRelations {
+            item: Serie {
+                id: "local-serie-id".to_string(),
+                name: "Sugar".to_string(),
+                tmdb: Some(203744),
+                tvdb: Some(421070),
+                ..Default::default()
+            },
+            relations: None,
+        };
+
+        let fallback = external_serie_image_fallback(
+            "tmdb:203744",
+            RsIds::from_tmdb(203744),
+            Some(resolved),
+        );
+
+        match fallback {
+            ExternalSerieImageFallback::RetryWithResolvedLocalId(local_id) => {
+                assert_eq!(local_id, "local-serie-id");
+            }
+            _ => panic!("expected local-id retry"),
+        }
+    }
+
+    #[test]
+    fn external_serie_image_fallback_retries_with_enriched_ids_for_external_results() {
+        let resolved = ItemWithRelations {
+            item: Serie {
+                id: "tmdb:203744".to_string(),
+                name: "Sugar".to_string(),
+                tmdb: Some(203744),
+                tvdb: Some(421070),
+                ..Default::default()
+            },
+            relations: None,
+        };
+
+        let fallback = external_serie_image_fallback(
+            "tmdb:203744",
+            RsIds::from_tmdb(203744),
+            Some(resolved),
+        );
+
+        match fallback {
+            ExternalSerieImageFallback::RetryWithEnrichedLookup { name, ids } => {
+                assert_eq!(name, "Sugar");
+                assert_eq!(ids.tmdb(), Some(203744));
+                assert_eq!(ids.tvdb(), Some(421070));
+            }
+            _ => panic!("expected enriched lookup retry"),
+        }
+    }
+}