use answer_message_varianted_silence_flag in replace message

reason: to be able to silence if it used as fallback in replace_message

src/db/mod.rs

@@ -103,6 +103,7 @@ pub struct Message {
     pub chat_id: i64,
     pub message_id: i64,
     pub token: String,
+    pub variant: Option<String>,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -299,6 +300,32 @@ pub trait CallDB {
         Ok(())
     }
 
+    async fn set_message_literal_variant(
+        &mut self,
+        chatid: i64,
+        messageid: i32,
+        literal: &str,
+        variant: &str,
+    ) -> DbResult<()> {
+        let db = self.get_database().await;
+        let messages = db.collection::<Message>("messages");
+
+        messages
+            .update_one(
+                doc! {
+                    "chat_id": chatid,
+                    "message_id": messageid as i64
+                },
+                doc! {
+                    "$set": { "token": literal, "variant": variant }
+                },
+            )
+            .upsert(true)
+            .await?;
+
+        Ok(())
+    }
+
     async fn get_literal(&mut self, literal: &str) -> DbResult<Option<Literal>> {
         let db = self.get_database().await;
         let messages = db.collection::<Literal>("literals");

src/main.rs

@@ -777,17 +777,29 @@ async fn answer_message_varianted<RM: Into<ReplyMarkup>>(
     variant: Option<&str>,
     keyboard: Option<RM>,
 ) -> BotResult<()> {
-    let variant = match variant {
+    answer_message_varianted_silence_flag(bot, chat_id, db, literal, variant, false, keyboard).await
+}
+
+async fn answer_message_varianted_silence_flag<RM: Into<ReplyMarkup>>(
+    bot: &Bot,
+    chat_id: i64,
+    db: &mut DB,
+    literal: &str,
+    variant: Option<&str>,
+    silence_non_variant: bool,
+    keyboard: Option<RM>,
+) -> BotResult<()> {
+    let variant_text = match variant {
         Some(variant) => {
             let value = db.get_literal_alternative_value(literal, variant).await?;
-            if value.is_none() {
+            if value.is_none() && !silence_non_variant {
                 notify_admin(&format!("variant {variant} for literal {literal} is not found! falling back to just literal")).await;
             }
             value
         }
         None => None,
     };
-    let text = match variant {
+    let text = match variant_text {
         Some(text) => text,
         None => db
             .get_literal_value(literal)
@@ -907,7 +919,13 @@ async fn answer_message_varianted<RM: Into<ReplyMarkup>>(
             (msg[0].chat.id.0, msg[0].id.0)
         }
     };
-    db.set_message_literal(chat_id, msg_id, literal).await?;
+    match variant {
+        Some(variant) => {
+            db.set_message_literal_variant(chat_id, msg_id, literal, variant)
+                .await?
+        }
+        None => db.set_message_literal(chat_id, msg_id, literal).await?,
+    };
     Ok(())
 }
 
@@ -919,10 +937,21 @@ async fn replace_message(
     literal: &str,
     keyboard: Option<InlineKeyboardMarkup>,
 ) -> BotResult<()> {
-    let text = db
-        .get_literal_value(literal)
+    let variant = db
+        .get_message(chat_id, message_id)
         .await?
-        .unwrap_or("Please, set content of this message".into());
+        .and_then(|m| m.variant);
+    let variant_text = match variant {
+        Some(ref variant) => db.get_literal_alternative_value(literal, variant).await?,
+        None => None,
+    };
+    let text = match variant_text {
+        Some(ref text) => text.to_string(),
+        None => db
+            .get_literal_value(literal)
+            .await?
+            .unwrap_or("Please, set content of this message".into()),
+    };
     let media = db.get_media(literal).await?;
     let (chat_id, msg_id) = match media.len() {
         // just a text
@@ -942,7 +971,16 @@ async fn replace_message(
                 {
                     // fallback to sending message
                     warn!("Fallback into sending message instead of editing because it contains media");
-                    return answer_message(bot, chat_id, db, literal, keyboard).await;
+                    return answer_message_varianted_silence_flag(
+                        bot,
+                        chat_id,
+                        db,
+                        literal,
+                        variant.as_deref(),
+                        true,
+                        keyboard,
+                    )
+                    .await;
                 }
                 Err(err) => return Err(err.into()),
             };