Add ability to mention users without usernames

Author: linyinfeng

Cargo.lock

@@ -1,7 +1,7 @@
 [package]
 name = "commit-notifier"
 authors = [ "Lin Yinfeng <[email protected]>" ]
-version = "0.2.0"
+version = "0.2.1"
 edition = "2024"
 description = """
 A simple bot tracking git commits/PRs/issues/branches

Cargo.toml

@@ -1,9 +1,11 @@
 use std::collections::{BTreeMap, BTreeSet};
 
 use serde::{Deserialize, Serialize};
-use teloxide::utils::markdown;
+use teloxide::{types::User, utils::markdown};
 use url::Url;
 
+use crate::error::Error;
+
 #[derive(Debug, Clone, Serialize, Deserialize, Default)]
 pub struct ChatRepoSettings {
     #[serde(default, alias = "pull_requests")]
@@ -73,14 +75,50 @@ impl NotifySettings {
 }
 
 #[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Serialize, Deserialize)]
+#[serde(try_from = "SubscriberCompat")]
 pub enum Subscriber {
-    Telegram { username: String },
+    Telegram { markdown_mention: String },
+}
+
+impl TryFrom<SubscriberCompat> for Subscriber {
+    type Error = Error;
+
+    fn try_from(compat: SubscriberCompat) -> Result<Self, Self::Error> {
+        match &compat {
+            SubscriberCompat::Telegram {
+                markdown_mention,
+                username,
+            } => match (markdown_mention, username) {
+                (Some(mention), _) => Ok(Subscriber::Telegram {
+                    markdown_mention: mention.clone(),
+                }),
+                (_, Some(username)) => Ok(Subscriber::Telegram {
+                    markdown_mention: format!("@{username}"),
+                }),
+                (_, _) => Err(Error::InvalidSubscriber(compat)),
+            },
+        }
+    }
+}
+
+#[derive(PartialEq, Eq, PartialOrd, Ord, Debug, Clone, Deserialize)]
+pub enum SubscriberCompat {
+    Telegram {
+        markdown_mention: Option<String>,
+        username: Option<String>, // field for compatibility
+    },
 }
 
 impl Subscriber {
-    fn markdown(&self) -> String {
+    pub fn from_tg_user(u: &User) -> Self {
+        Self::Telegram {
+            markdown_mention: markdown::user_mention_or_link(u),
+        }
+    }
+
+    pub fn markdown(&self) -> &str {
         match self {
-            Subscriber::Telegram { username } => format!("@{}", markdown::escape(username)),
+            Subscriber::Telegram { markdown_mention } => markdown_mention,
         }
     }
 }

src/chat/settings.rs

@@ -5,6 +5,7 @@ use teloxide::types::ReplyParameters;
 use thiserror::Error;
 use tokio::sync::Mutex;
 
+use crate::chat::settings::SubscriberCompat;
 use crate::github::GitHubInfo;
 
 #[derive(Error, Debug)]
@@ -104,8 +105,6 @@ pub enum Error {
     SubscribeCallbackNoChatId,
     #[error("can not determine message id from subscribe callback query")]
     SubscribeCallbackNoMsgId,
-    #[error("can not determine username from subscribe callback query")]
-    SubscribeCallbackNoUsername,
     #[error("can not get data from subscribe callback query")]
     SubscribeCallbackNoData,
     #[error("invalid kind '{0}' in subscribe callback data")]
@@ -118,6 +117,8 @@ pub enum Error {
     UnsupportedPRIssueUrl(String),
     #[error("not in an admin chat")]
     NotAdminChat,
+    #[error("invalid subscriber: {0:?}")]
+    InvalidSubscriber(SubscriberCompat),
 }
 
 impl Error {

src/error.rs

@@ -34,6 +34,7 @@ use teloxide::types::InlineKeyboardButton;
 use teloxide::types::InlineKeyboardButtonKind;
 use teloxide::types::InlineKeyboardMarkup;
 use teloxide::types::ParseMode;
+use teloxide::types::User;
 use teloxide::update_listeners;
 use teloxide::utils::command::BotCommands;
 use teloxide::utils::markdown;
@@ -325,8 +326,8 @@ async fn handle_callback_query_command_result(
     query: &CallbackQuery,
 ) -> Result<String, CommandError> {
     log::debug!("query = {query:?}");
-    let (chat_id, username) = get_chat_id_and_username_from_query(query)?;
-    let subscriber = Subscriber::Telegram { username };
+    let (chat_id, user) = get_chat_id_and_user_from_query(query)?;
+    let subscriber = Subscriber::from_tg_user(&user);
     let _msg = query
         .message
         .as_ref()
@@ -388,15 +389,10 @@ async fn handle_callback_query_command_result(
     }
 }
 
-fn get_chat_id_and_username_from_query(query: &CallbackQuery) -> Result<(ChatId, String), Error> {
+fn get_chat_id_and_user_from_query(query: &CallbackQuery) -> Result<(ChatId, User), Error> {
     let chat_id = query.chat_id().ok_or(Error::SubscribeCallbackNoChatId)?;
-    let username = query
-        .from
-        .username
-        .as_ref()
-        .ok_or(Error::SubscribeCallbackNoUsername)?
-        .clone();
-    Ok((chat_id, username))
+    let user = query.from.clone();
+    Ok((chat_id, user))
 }
 
 enum CommandError {

src/main.rs

@@ -190,10 +190,5 @@ where
 }
 
 pub fn subscriber_from_msg(msg: &Message) -> Option<Subscriber> {
-    match &msg.from {
-        None => None,
-        Some(u) => u.username.as_ref().map(|name| Subscriber::Telegram {
-            username: name.to_string(),
-        }),
-    }
+    msg.from.as_ref().map(Subscriber::from_tg_user)
 }