refac: fallback lang instead of filtering

api/src/domain/ingredient/fetch_list.rs

@@ -44,7 +44,7 @@ mod tests {
     }
 
     #[test]
-    fn should_return_filtered_by_lang() {
+    fn should_return_preferred_lang_with_fallback() {
         let repo = crate::repo::ingredient::InMemoryIngredientRepo::new();
         let res = execute(
             &repo,
@@ -55,14 +55,22 @@ mod tests {
         );
 
         match res.as_slice() {
-            [apple, salt] => {
+            [apple, orange, salt, sugar] => {
                 assert_eq!(apple.key, String::from("apple"));
                 assert_eq!(apple.lang, Lang::Eng);
                 assert_eq!(apple.name, String::from("Apple"));
 
+                assert_eq!(orange.key, String::from("orange"));
+                assert_eq!(orange.lang, Lang::Rus);
+                assert_eq!(orange.name, String::from("Апельсин"));
+
                 assert_eq!(salt.key, String::from("salt"));
                 assert_eq!(salt.lang, Lang::Eng);
                 assert_eq!(salt.name, String::from("Salt"));
+
+                assert_eq!(sugar.key, String::from("sugar"));
+                assert_eq!(sugar.lang, Lang::Rus);
+                assert_eq!(sugar.name, String::from("Сахар"));
             }
             _ => unimplemented!(),
         }

api/src/domain/ingredient/types.rs

@@ -38,26 +38,18 @@ impl From<&db::data::Ingredient> for Ingredient {
     }
 }
 
-#[derive(Debug)]
-pub enum IngredientValidError {
-    TranslationNotFound,
-}
-
-impl TryFrom<(&db::data::Ingredient, Lang)> for Ingredient {
-    type Error = IngredientValidError;
-
-    fn try_from((db, lang): (&db::data::Ingredient, Lang)) -> Result<Self, Self::Error> {
-        let key = db.key.to_string();
-
+impl From<(&db::data::Ingredient, Lang)> for Ingredient {
+    fn from((db, lang): (&db::data::Ingredient, Lang)) -> Self {
+        let tr = &db.translates;
         let name = match lang {
-            Lang::Rus => Some(db.translates.ru),
-            Lang::Eng => db.translates.en,
+            Lang::Rus => tr.ru,
+            Lang::Eng => tr.en.unwrap_or(tr.ru),
         };
 
-        if let Some(name) = name.map(String::from) {
-            Ok(Self { key, lang, name })
-        } else {
-            Err(IngredientValidError::TranslationNotFound)
+        Self {
+            key: db.key.to_string(),
+            lang: if name == tr.ru { Lang::Rus } else { lang },
+            name: name.to_string(),
         }
     }
 }

api/src/repo/ingredient.rs

@@ -27,7 +27,7 @@ impl IngredientRepo for StaticIngredientRepo {
         db::INGREDIENTS
             .iter()
             .zip(langs)
-            .filter_map(|tup| types::Ingredient::try_from(tup).ok())
+            .map(types::Ingredient::from)
             .filter(|ing| opts.keys.is_none() || opts.keys.as_ref().unwrap().contains(&ing.key))
             .collect::<Vec<_>>()
     }
@@ -83,7 +83,7 @@ impl IngredientRepo for InMemoryIngredientRepo {
         self.ingredients
             .iter()
             .zip(langs)
-            .filter_map(|tup| types::Ingredient::try_from(tup).ok())
+            .map(types::Ingredient::from)
             .filter(|ing| opts.keys.is_none() || opts.keys.as_ref().unwrap().contains(&ing.key))
             .collect::<Vec<_>>()
     }