How I “try|tried” in Rust

I am the CEO of my company MediaRise (the company has just started to develop), with a technical background. I like to write in different languages, or rather try to work with them. I have long heard about such a language as Rust.

Rust is a modern systems programming language designed for high performance and safety, especially when working with concurrent processes. Originally developed by Mozilla and now maintained by the Rust Foundation, Rust is gaining popularity due to its reliability and efficiency.

I was thinking about an idea of ​​what to implement in this language. Since I have a friend Thai, there are problems when communicating in messengers, I wanted to write a telegram bot that would bidirectionally translate from Russian to Thai and vice versa in the group chat.

I understand that there are ready-made solutions, but I wanted to create my own bike, try out the new Rust language.

There is an idea, there is no problem with the telegram bot, but there is a problem with the service that will translate from one language to another. The choice fell on LibreTranslate. To use it for free, you need to deploy the application on your server. I did it, installed the dependencies, deployed it in a Docker container. There were no problems. The only thing is that the application needs to be run with the flag: ./run.sh –api-keys, in order to get the api_key. You can read more about setting up and getting the LiberTranslate api-key on the official website

Having deployed the LiberTranslate server and received the telegram bot token, it remains to implement the application. Having reviewed the official documentation on Rust and the developments on github, I began to create. I installed rust and corgo (registry (manager) of packages for Rust). Having studied the documentation of the teloxide library for the telegram bot written in rust, I wrote a handler for message events in the chat.

#[tokio::main]
async fn main() -> ResponseResult<()> {
    dotenv().ok();
    env_logger::init();
    let token_bot = env::var("TELEGRAM_BOT_KEY").expect("TELEGRAM_BOT_KEY not found");

    let bot = teloxide::Bot::new(&token_bot).parse_mode(ParseMode::Html);

    // Create a handler for our bot, that will process updates from Telegram
    let handler = dptree::entry()
        .inspect(|u: Update| {
                    eprintln!("{u:#?}"); // Print the update to the console with inspect
        })

   ...

        .branch(
            Update::filter_message()
                .branch(
                    dptree::endpoint(translate_message),
                )
        );

    // Create a dispatcher for our bot
    Dispatcher::builder(bot, handler).enable_ctrlc_handler().build().dispatch().await;

    Ok(())
}

async fn translate_message(bot: Bot, msg: Message) -> ResponseResult<()> {
    if let Some(text) = msg.text() {

        match translate(text).await {
            Ok(translated_word) => {
                bot.send_message(msg.chat.id, translated_word).await?;
            }
            Err(e) => {
                bot.send_message(msg.chat.id, format!("Translation error: {}", e)).await?;
            }
        }
    } else {
        bot.send_message(msg.chat.id, "Send me plain text.").await?;
    }

    Ok(())
}

Next, the function itself for requesting a translation from the LiberTranslate application. The gist is this: the translation application determines what language the message is in and translates it into the required language (ru -> th, th -> ru)

async fn translate(text: &str) -> ResponseResult<String> {
    let client = reqwest::Client::new();

    let api_translate_url = env::var("API_TRANSLATE_URL").expect("API_TRANSLATE_URL not found");
    let api_translate_key = env::var("API_TRANSLATE_KEY").expect("API_TRANSLATE_KEY not found");
    let api_detect_url = env::var("API_DETECT_URL").expect("API_DETECT_URL not found");
    eprintln!("{text:#?}");

    let detect_request = DetectRequest {
        q: String::from(text),
        api_key: String::from(api_translate_key.clone()),
    };

    let res = client.post(api_detect_url)
        .header("Content-Type", "application/x-www-form-urlencoded")
        .form(&detect_request)
        .send()
        .await?;
    let resp_json = res.json::<Vec<DetectResponse>>().await?;

    let lang = &resp_json[0].language;

    eprintln!("{lang:#?}");
    let target_lang = if lang == "ru" { "th" } else { "ru" };

    let json_object = json!({
                "q": text,
                "source": "auto",
                "target": target_lang,
                "format": "text",
                "alternatives": 3,
                "api_key": api_translate_key
            });

    let json_string = serde_json::to_string(&json_object).unwrap();


    let res = client.post(api_translate_url)
        .body(json_string)
        .header("Content-Type", "application/json")
        .send()
        .await?;

    let resp_json = res.json::<TranslateResult>().await?;
    let translated_word = resp_json.translatedText;
    Ok(translated_word)
}

Here is the result in the Telegram chat itself

There were problems with bugs, which were due to the fact that I used old libraries in Rust, when I tried to solve the problem with ChatGPT. But the live experience of developers from GitHub helped more, where I looked at the implementation of some functionality: API documentation of the bot, working with env (environment files), examples of working with json, sending rest requests and also the work of the language structure.

I am very happy with the working application, because I have not written in Rust before and it inspired me to study it further. Experienced developers will certainly tell me how to optimize the code, which I will be very happy about.

All that remains is to build the application and run it in daemon mode on the server

cargo build --release

[Unit]
Description=Translate Bot
After=network.target

[Service]
ExecStart=/path/to/your/application
Restart=always
User=yourusername
Group=yourgroupname
Environment=/path/to/your/.env
WorkingDirectory=/path/to/your/application/directory

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload

sudo systemctl start translate_bot

sudo systemctl status translate_bot

sudo systemctl enable rust_service

PS I would also like to solve the problem with env files so that they can be accessed in the function from main.

Next in the plans: I would like to implement event handling if a new user appears in the chat (as well as a live chat). The user can choose the language in which he would like to receive the translation. The users themselves and their settings will be stored in the PostgreSQL database

Thank you all for your attention! I have posted the source code on GitHub.

Source on GitHub