How to create a private bot // limiting by chat_id?

[hendrikmaus]

I was wondering if there is an idiomatic way to limit a bot to one or more chat_id's in order to create private bots.

[JasterV]

The easiest thing that you could do is to have the allowed id's stored in a ddbb, or even hardcoded in an array.
For the second option you could just have a file named allowed_ids:

allowed_ids.rs

pub const allowed_ids: [i64; 2] = [1826330247, 2340573957];

You could even read the allowed_ids from an env variable with the ids separated by commas, then on the allowed_ids.rs file I would export a function that reads from that variable and returns a Vec.

Then just assert the sender chat_id against the array:

allowed_ids.contains(&chat_id);

or

allowed_ids.iter().any(|id| id == chat_id)

[hendrikmaus]

Thanks for getting back to me. That reads very similar to my playground experiment based on the simple command example. I try the chat id early in the command handler answer and return an error for logging. The user does not get a response.

use teloxide::{prelude::*, utils::command::BotCommand};

use std::error::Error;

const ALLOWED_IDS: [i64; 2] = [1826330247, 2340573957];

#[derive(BotCommand)]
#[command(rename = "lowercase", description = "These commands are supported:")]
enum Command {
    #[command(description = "display this text.")]
    Help,
    #[command(description = "handle a username.")]
    Username(String),
    #[command(description = "handle a username and an age.", parse_with = "split")]
    UsernameAndAge { username: String, age: u8 },
}

#[derive(thiserror::Error, Debug)]
enum BotError {
    #[error("Unknown chat_id detected: {0}")]
    UnknownChatID(i64),
}

fn try_auth(chat_id: &i64) -> Result<(), Box<BotError>> {
    if ALLOWED_IDS.contains(chat_id) {
        Ok(())
    } else {
        Err(BotError::UnknownChatID(*chat_id).into())
    }
}

async fn answer(
    cx: UpdateWithCx<AutoSend<Bot>, Message>,
    command: Command,
) -> Result<(), Box<dyn Error + Send + Sync>> {
    try_auth(&cx.chat_id())?;

    match command {
        Command::Help => cx.answer(Command::descriptions()).await?,
        Command::Username(username) => {
            cx.answer(format!("Your username is @{}.", username)).await?
        }
        Command::UsernameAndAge { username, age } => {
            cx.answer(format!("Your username is @{} and age is {}.", username, age)).await?
        }
    };

    Ok(())
}

#[tokio::main]
async fn main() {
    run().await;
}

async fn run() {
    teloxide::enable_logging!();
    log::info!("Starting simple_commands_bot...");

    let bot = Bot::from_env().auto_send();

    let bot_name: String = "bot demo".into();
    teloxide::commands_repl(bot, bot_name, answer).await;
}

[hendrikmaus]

I adjusted it a bit according to your example, of course.

[JasterV]

I see you are using thiserror to handle errors. I've also done that on a teloxide bot project but I have an extra step to handle errors & return messages manually.

Here is how I handle a message:

  async fn handle_message(&mut self, Message(cx, command): Message) -> Result<()> {
        let result = match command {
            GameCommand::Ask(to, card) => self.ask(&cx, to, card).await,
            GameCommand::Join => self.join(&cx).await,
            GameCommand::Start => self.start(&cx).await,
            GameCommand::Status => self.status(&cx).await,
        };

        if let Err(root_err) = result {
            let message = match root_err.downcast_ref::<ActionError>() {
                Some(err) => match err {
                    ActionError::InvalidQuestion(_, _) => INVALID_QUESTION,
                    ActionError::InvalidPlayerId(_) => INVALID_PLAYER,
                    ActionError::CannotAsk(_) => NOT_YOUR_TURN,
                    ActionError::CannotDraw(_) => ERROR_DRAWING,
                    ActionError::GameAlreadyStarted => GAME_ALREADY_STARTED,
                    ActionError::PlayerAlreadyJoined(_) => ALREADY_JOINED,
                },
                None => UNKNOWN_ERROR,
            };
            cx.answer(message).await?;
        }
        Ok(())
    }

I guess that teloxide won't convert your BotError to String & automatically return it as a response, so you can do something similar to what I did, hope it helps!