Add and use TranslationManager::check_tone.

5 files changed, 42 insertions, 49 deletions

diff --git a/td/generate/scheme/td_api.tl b/td/generate/scheme/td_api.tl
index c2d13df7f..6371009ed 100644
--- a/td/generate/scheme/td_api.tl
+++ b/td/generate/scheme/td_api.tl
@@ -11916,7 +11916,7 @@ translateText text:formattedText to_language_code:string tone:string = Formatted
 //@description Translates a rich message to the given language
 //@message Rich message to translate
 //@to_language_code Language code of the language to which the message is translated. See translateText.to_language_code for the list of supported values
-//@tone Tone of the translation; must be one of "", "formal", "neutral", "casual"; defaults to "neutral"
+//@tone Tone of the translation; see translateText.tone for the list of supported values
 translateRichMessage message:inputRichMessage to_language_code:string tone:string = RichMessage;
 
 //@description Extracts text or caption of the given message and translates it to the given language; must not be used in secret chats. If the current user is a Telegram Premium user, then text formatting is preserved
diff --git a/td/telegram/MessageQueryManager.cpp b/td/telegram/MessageQueryManager.cpp
index ded245dff..40a098acd 100644
--- a/td/telegram/MessageQueryManager.cpp
+++ b/td/telegram/MessageQueryManager.cpp
@@ -43,6 +43,7 @@
 #include "td/telegram/TdDb.h"
 #include "td/telegram/telegram_api.h"
 #include "td/telegram/ToDoItem.h"
+#include "td/telegram/TranslationManager.h"
 #include "td/telegram/UpdatesManager.h"
 #include "td/telegram/UserId.h"
 #include "td/telegram/UserManager.h"
@@ -1135,14 +1136,11 @@ class SummarizeTextQuery final : public Td::ResultHandler {
       : promise_(std::move(promise)) {
   }
 
-  void send(DialogId dialog_id, MessageId message_id, const string &to_language_code, string tone) {
+  void send(DialogId dialog_id, MessageId message_id, const string &to_language_code, const string &tone) {
     int32 flags = 0;
     if (!to_language_code.empty()) {
       flags |= telegram_api::messages_summarizeText::TO_LANG_MASK;
     }
-    if (tone == "neutral") {
-      tone.clear();
-    }
     if (!tone.empty()) {
       flags |= telegram_api::messages_summarizeText::TONE_MASK;
     }
@@ -3096,7 +3094,7 @@ void MessageQueryManager::do_get_paid_message_reaction_senders(
 }
 
 void MessageQueryManager::summarize_message_text(MessageFullId message_full_id, const string &to_language_code,
-                                                 const string &tone,
+                                                 string tone,
                                                  Promise<td_api::object_ptr<td_api::formattedText>> &&promise) {
   auto dialog_id = message_full_id.get_dialog_id();
   TRY_STATUS_PROMISE(promise, td_->dialog_manager_->check_dialog_access(dialog_id, false, AccessRights::Read,
@@ -3104,9 +3102,7 @@ void MessageQueryManager::summarize_message_text(MessageFullId message_full_id,
   if (!td_->messages_manager_->have_message_force(message_full_id, "summarize_message_text")) {
     return promise.set_error(400, "Message not found");
   }
-  if (tone != string() && tone != "formal" && tone != "neutral" && tone != "casual") {
-    return promise.set_error(400, "Invalid tone specified");
-  }
+  TRY_STATUS_PROMISE(promise, TranslationManager::check_tone(tone));
   auto message_id = message_full_id.get_message_id();
   if (!message_id.is_server()) {
     return promise.set_error(400, "Message can't be summarized");
diff --git a/td/telegram/MessageQueryManager.h b/td/telegram/MessageQueryManager.h
index 777b5c50f..9603c4ddb 100644
--- a/td/telegram/MessageQueryManager.h
+++ b/td/telegram/MessageQueryManager.h
@@ -172,7 +172,7 @@ class MessageQueryManager final : public Actor {
   void get_paid_message_reaction_senders(DialogId dialog_id,
                                          Promise<td_api::object_ptr<td_api::messageSenders>> &&promise);
 
-  void summarize_message_text(MessageFullId message_full_id, const string &to_language_code, const string &tone,
+  void summarize_message_text(MessageFullId message_full_id, const string &to_language_code, string tone,
                               Promise<td_api::object_ptr<td_api::formattedText>> &&promise);
 
   void add_to_do_list_tasks(MessageFullId message_full_id,
diff --git a/td/telegram/TranslationManager.cpp b/td/telegram/TranslationManager.cpp
index ef59a56b7..f0d3af9e6 100644
--- a/td/telegram/TranslationManager.cpp
+++ b/td/telegram/TranslationManager.cpp
@@ -37,11 +37,9 @@ class TranslateTextQuery final : public Td::ResultHandler {
       : promise_(std::move(promise)) {
   }
 
-  void send(vector<FormattedText> &&texts, MessageFullId message_full_id, const string &to_language_code, string tone) {
+  void send(vector<FormattedText> &&texts, MessageFullId message_full_id, const string &to_language_code,
+            const string &tone) {
     int32 flags = 0;
-    if (tone == "neutral") {
-      tone.clear();
-    }
     if (!tone.empty()) {
       flags |= telegram_api::messages_translateText::TONE_MASK;
     }
@@ -101,9 +99,6 @@ class TranslateRichMessageQuery final : public Td::ResultHandler {
 
   void send(RichMessage &&rich_message, MessageFullId message_full_id, const string &to_language_code, string tone) {
     int32 flags = 0;
-    if (tone == "neutral") {
-      tone.clear();
-    }
     if (!tone.empty()) {
       flags |= telegram_api::messages_translateRichMessage::TONE_MASK;
     }
@@ -605,6 +600,15 @@ void TranslationManager::on_authorization_success() {
   }
 }
 
+Status TranslationManager::check_tone(string &tone) {
+  if (tone == "neutral") {
+    tone.clear();
+  } else if (!tone.empty() && tone != "formal" && tone != "casual") {
+    return Status::Error(400, "Invalid tone specified");
+  }
+  return Status::OK();
+}
+
 telegram_api::object_ptr<telegram_api::InputAiComposeTone> TranslationManager::clone_input_ai_compose_tone(
     const telegram_api::object_ptr<telegram_api::InputAiComposeTone> &input_tone) {
   if (input_tone == nullptr) {
@@ -666,22 +670,17 @@ Result<TranslationManager::InputText> TranslationManager::get_input_text(
 }
 
 void TranslationManager::translate_text(td_api::object_ptr<td_api::formattedText> &&text,
-                                        const string &to_language_code, const string &tone,
+                                        const string &to_language_code, string tone,
                                         Promise<td_api::object_ptr<td_api::formattedText>> &&promise) {
   TRY_RESULT_PROMISE(promise, input_text, get_input_text(std::move(text)));
-  translate_text(std::move(input_text), MessageFullId(), to_language_code, tone, std::move(promise));
+  translate_text(std::move(input_text), MessageFullId(), to_language_code, std::move(tone), std::move(promise));
 }
 
 void TranslationManager::translate_text(InputText &&text, MessageFullId message_full_id, const string &to_language_code,
-                                        const string &tone,
-                                        Promise<td_api::object_ptr<td_api::formattedText>> &&promise) {
+                                        string tone, Promise<td_api::object_ptr<td_api::formattedText>> &&promise) {
+  TRY_STATUS_PROMISE(promise, check_tone(tone));
   vector<FormattedText> texts;
   texts.push_back(std::move(text.text_));
-
-  if (tone != string() && tone != "formal" && tone != "neutral" && tone != "casual") {
-    return promise.set_error(400, "Invalid tone specified");
-  }
-
   auto query_promise = PromiseCreator::lambda(
       [actor_id = actor_id(this), skip_bot_commands = text.skip_bot_commands_,
        max_media_timestamp = text.max_media_timestamp_, promise = std::move(promise)](
@@ -724,19 +723,17 @@ Result<TranslationManager::InputRichMessage> TranslationManager::get_input_rich_
 }
 
 void TranslationManager::translate_rich_message(td_api::object_ptr<td_api::inputRichMessage> &&message,
-                                                const string &to_language_code, const string &tone,
+                                                const string &to_language_code, string tone,
                                                 Promise<td_api::object_ptr<td_api::richMessage>> &&promise) {
   TRY_RESULT_PROMISE(promise, input_rich_message, get_input_rich_message(std::move(message)));
-  translate_rich_message(std::move(input_rich_message), MessageFullId(), to_language_code, tone, std::move(promise));
+  translate_rich_message(std::move(input_rich_message), MessageFullId(), to_language_code, std::move(tone),
+                         std::move(promise));
 }
 
 void TranslationManager::translate_rich_message(InputRichMessage &&input_rich_message, MessageFullId message_full_id,
-                                                const string &to_language_code, const string &tone,
+                                                const string &to_language_code, string tone,
                                                 Promise<td_api::object_ptr<td_api::richMessage>> &&promise) {
-  if (tone != string() && tone != "formal" && tone != "neutral" && tone != "casual") {
-    return promise.set_error(400, "Invalid tone specified");
-  }
-
+  TRY_STATUS_PROMISE(promise, check_tone(tone));
   auto query_promise =
       PromiseCreator::lambda([actor_id = actor_id(this), skip_bot_commands = input_rich_message.skip_bot_commands_,
                               promise = std::move(promise)](
@@ -747,12 +744,12 @@ void TranslationManager::translate_rich_message(InputRichMessage &&input_rich_me
         send_closure(actor_id, &TranslationManager::on_get_translated_rich_messages, result.move_as_ok(),
                      skip_bot_commands, std::move(promise));
       });
-  do_translate_rich_message(std::move(input_rich_message.message_), message_full_id, to_language_code, tone,
+  do_translate_rich_message(std::move(input_rich_message.message_), message_full_id, to_language_code, std::move(tone),
                             std::move(query_promise));
 }
 
 void TranslationManager::do_translate_rich_message(
-    RichMessage &&rich_message, MessageFullId message_full_id, const string &to_language_code, const string &tone,
+    RichMessage &&rich_message, MessageFullId message_full_id, const string &to_language_code, string tone,
     Promise<vector<telegram_api::object_ptr<telegram_api::richMessage>>> &&promise) {
   TRY_STATUS_PROMISE(promise, G()->close_status());
   td_->create_handler<TranslateRichMessageQuery>(std::move(promise))
@@ -774,8 +771,7 @@ void TranslationManager::on_get_translated_rich_messages(
 }
 
 void TranslationManager::compose_message_with_ai(td_api::object_ptr<td_api::formattedText> &&text,
-                                                 const string &translate_to_language_code, const string &tone,
-                                                 bool emojify,
+                                                 const string &translate_to_language_code, string tone, bool emojify,
                                                  Promise<td_api::object_ptr<td_api::formattedText>> &&promise) {
   TRY_RESULT_PROMISE(promise, input_text, get_input_text(std::move(text)));
   TRY_RESULT_PROMISE(promise, input_tone, ai_compose_tones_.get_input_ai_compose_tone(tone));
@@ -798,7 +794,7 @@ void TranslationManager::do_compose_rich_message_with_ai(
 }
 
 void TranslationManager::compose_rich_message_with_ai(td_api::object_ptr<td_api::inputRichMessage> &&message,
-                                                      const string &translate_to_language_code, const string &tone,
+                                                      const string &translate_to_language_code, string tone,
                                                       const string &custom_prompt, bool emojify,
                                                       Promise<td_api::object_ptr<td_api::richMessage>> &&promise) {
   TRY_RESULT_PROMISE(promise, input_rich_message, get_input_rich_message(std::move(message)));
diff --git a/td/telegram/TranslationManager.h b/td/telegram/TranslationManager.h
index fe9ed19d0..9a41b9bee 100644
--- a/td/telegram/TranslationManager.h
+++ b/td/telegram/TranslationManager.h
@@ -30,6 +30,8 @@ class TranslationManager final : public Actor {
 
   void on_authorization_success();
 
+  static Status check_tone(string &tone);
+
   static telegram_api::object_ptr<telegram_api::InputAiComposeTone> clone_input_ai_compose_tone(
       const telegram_api::object_ptr<telegram_api::InputAiComposeTone> &input_tone);
 
@@ -39,11 +41,11 @@ class TranslationManager final : public Actor {
     int32 max_media_timestamp_ = -1;
   };
 
-  void translate_text(td_api::object_ptr<td_api::formattedText> &&text, const string &to_language_code,
-                      const string &tone, Promise<td_api::object_ptr<td_api::formattedText>> &&promise);
+  void translate_text(td_api::object_ptr<td_api::formattedText> &&text, const string &to_language_code, string tone,
+                      Promise<td_api::object_ptr<td_api::formattedText>> &&promise);
 
-  void translate_text(InputText &&text, MessageFullId message_full_id, const string &to_language_code,
-                      const string &tone, Promise<td_api::object_ptr<td_api::formattedText>> &&promise);
+  void translate_text(InputText &&text, MessageFullId message_full_id, const string &to_language_code, string tone,
+                      Promise<td_api::object_ptr<td_api::formattedText>> &&promise);
 
   struct InputRichMessage {
     RichMessage message_;
@@ -51,18 +53,18 @@ class TranslationManager final : public Actor {
   };
 
   void translate_rich_message(td_api::object_ptr<td_api::inputRichMessage> &&message, const string &to_language_code,
-                              const string &tone, Promise<td_api::object_ptr<td_api::richMessage>> &&promise);
+                              string tone, Promise<td_api::object_ptr<td_api::richMessage>> &&promise);
 
   void translate_rich_message(InputRichMessage &&input_rich_message, MessageFullId message_full_id,
-                              const string &to_language_code, const string &tone,
+                              const string &to_language_code, string tone,
                               Promise<td_api::object_ptr<td_api::richMessage>> &&promise);
 
   void do_translate_rich_message(RichMessage &&rich_message, MessageFullId message_full_id,
-                                 const string &to_language_code, const string &tone,
+                                 const string &to_language_code, string tone,
                                  Promise<vector<telegram_api::object_ptr<telegram_api::richMessage>>> &&promise);
 
   void compose_message_with_ai(td_api::object_ptr<td_api::formattedText> &&text,
-                               const string &translate_to_language_code, const string &tone, bool emojify,
+                               const string &translate_to_language_code, string tone, bool emojify,
                                Promise<td_api::object_ptr<td_api::formattedText>> &&promise);
 
   void do_compose_rich_message_with_ai(bool has_message, TranslationManager::InputRichMessage &&message,
@@ -72,9 +74,8 @@ class TranslationManager final : public Actor {
                                        Promise<td_api::object_ptr<td_api::richMessage>> &&promise);
 
   void compose_rich_message_with_ai(td_api::object_ptr<td_api::inputRichMessage> &&message,
-                                    const string &translate_to_language_code, const string &tone,
-                                    const string &custom_prompt, bool emojify,
-                                    Promise<td_api::object_ptr<td_api::richMessage>> &&promise);
+                                    const string &translate_to_language_code, string tone, const string &custom_prompt,
+                                    bool emojify, Promise<td_api::object_ptr<td_api::richMessage>> &&promise);
 
   void create_rich_message_with_ai(const string &prompt, const string &language_code, bool emojify,
                                    Promise<td_api::object_ptr<td_api::richMessage>> &&promise);