public async Task Handle(Message message)
{
await SendTypingNotification(message);
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
var messageBuilder = new StringBuilder();
if (chatConfig.IsBotStopped)
{
if (!await IsUserAdmin(message))
{
messageBuilder.AppendLine("Only admins can use this command.");
}
else
{
chatConfig.IsBotStopped = false;
await _chatConfigurationService.Update(chatConfig);
messageBuilder.AppendLine("Bot started");
}
}
else
{
messageBuilder.AppendLine("Bot is already started");
}
await Client.SendTextMessageAsync(message.Chat.Id, messageBuilder.ToString());
await NotifyIfBotIsNotAdmin(message);
}
public async Task Handle(Message message)
{
await SendTypingNotification(message);
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
var messageBuilder = new StringBuilder();
messageBuilder.AppendLine("Algorithms Available:");
messageBuilder.AppendLine(GetAvailableOptions(chatConfig.GrammarAlgorithm));
messageBuilder.AppendLine("Supported Languages:");
messageBuilder.AppendLine(GetAvailableOptions(chatConfig.SelectedLanguage));
var showCorrectionDetailsIcon = chatConfig.HideCorrectionDetails ? "❌" : "✅";
messageBuilder.AppendLine($"Show correction details {showCorrectionDetailsIcon}").AppendLine();
messageBuilder.AppendLine("Strictness level:").AppendLine($"{chatConfig.CorrectionStrictnessLevel.GetDescription()} ✅").AppendLine();
messageBuilder.AppendLine($"Whitelist Words:").AppendLine($"Type {TelegramBotCommands.WhiteList} to see Whitelist words configured.").AppendLine();
if (chatConfig.IsBotStopped)
{
messageBuilder.AppendLine($"The bot is currently stopped. Type {TelegramBotCommands.Start} to activate the Bot.");
}
await Client.SendTextMessageAsync(message.Chat.Id, messageBuilder.ToString());
await NotifyIfBotIsNotAdmin(message);
}
public async Task Handle(Message message)
{
await SendTypingNotification(message);
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
if (chatConfig.WhiteListWords?.Any() == true)
{
var messageBuilder = new StringBuilder();
messageBuilder.AppendLine("Whitelist Words:\n");
foreach (var word in chatConfig.WhiteListWords)
{
messageBuilder.AppendLine($"- {word}");
}
await Client.SendTextMessageAsync(message.Chat.Id, messageBuilder.ToString());
return;
}
await Client.SendTextMessageAsync(message.Chat.Id, $"You don't have Whitelist words configured. Use {TelegramBotCommands.AddWhiteList} to add words to the WhiteList.");
await NotifyIfBotIsNotAdmin(message);
}
private async Task <ChatConfiguration> GetChatConfiguration(long chatId)
{
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(chatId);
if (chatConfig != null)
{
return(chatConfig);
}
var chatConfiguration = new ChatConfiguration
{
ChatId = chatId,
GrammarAlgorithm = Defaults.DefaultAlgorithm,
SelectedLanguage = SupportedLanguages.Auto
};
await _chatConfigurationService.AddConfiguration(chatConfiguration);
return(chatConfiguration);
}
public async Task Handle(Message message)
{
await SendTypingNotification(message);
if (!await IsUserAdmin(message))
{
await Client.SendTextMessageAsync(message.Chat.Id, "Only admins can use this command.", replyToMessageId : message.MessageId);
return;
}
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
chatConfig.IsBotStopped = true;
await _chatConfigurationService.Update(chatConfig);
await Client.SendTextMessageAsync(message.Chat.Id, "Bot stopped");
}
public async Task HandleCallBackQuery(CallbackQuery callbackQuery)
{
var message = callbackQuery.Message;
if (!await IsUserAdmin(_client, callbackQuery.Message, callbackQuery.From))
{
var userMention = $"[{callbackQuery.From.FirstName} {callbackQuery.From.LastName}](tg://user?id={callbackQuery.From.Id})";
await _client.SendTextMessageAsync(message.Chat.Id, $"{userMention} Only admins can use this command.", ParseMode.Markdown);
return;
}
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
var enumTypeString = callbackQuery.Data.Split(".")[0];
if (enumTypeString == nameof(SupportedLanguages))
{
var languageSelectedString = callbackQuery.Data.Split(".")[1];
var languageSelected = Enum.GetValues(typeof(SupportedLanguages)).Cast <SupportedLanguages>().First(v => v.ToString() == languageSelectedString);
chatConfig.SelectedLanguage = languageSelected;
await _client.SendTextMessageAsync(message.Chat.Id, $"Language updated: {languageSelected.GetDescription()}");
}
else
{
var algorithmSelectedString = callbackQuery.Data.Split(".")[1];
var algorithmSelected = Enum.GetValues(typeof(GrammarAlgorithms)).Cast <GrammarAlgorithms>().First(v => v.ToString() == algorithmSelectedString);
chatConfig.GrammarAlgorithm = algorithmSelected;
await _client.SendTextMessageAsync(message.Chat.Id, $"Algorithm updated: {algorithmSelected.GetDescription()}");
}
await _chatConfigurationService.Update(chatConfig);
// Fire and forget
_ = _client.DeleteMessageAsync(callbackQuery.Message.Chat.Id, callbackQuery.Message.MessageId);
}
public async Task Handle(Message message)
{
await SendTypingNotification(message);
var messageBuilder = new StringBuilder();
if (!await IsUserAdmin(message))
{
messageBuilder.AppendLine("Only admins can use this command.");
await Client.SendTextMessageAsync(message.Chat.Id, messageBuilder.ToString(), replyToMessageId : message.MessageId);
return;
}
var parameters = message.Text.Split(" ");
if (parameters.Length == 1)
{
await ShowOptions <SupportedLanguages>(message, "Choose Language");
}
else
{
bool parsedOk = int.TryParse(parameters[1], out int language);
if (parsedOk && language.IsAssignableToEnum <SupportedLanguages>())
{
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
chatConfig.SelectedLanguage = (SupportedLanguages)language;
await _chatConfigurationService.Update(chatConfig);
await Client.SendTextMessageAsync(message.Chat.Id, "Language updated.");
}
else
{
await Client.SendTextMessageAsync(message.Chat.Id, $"Invalid parameter. Type {TelegramBotCommands.Language} <language_number> to set a language.");
}
}
await NotifyIfBotIsNotAdmin(message);
}
public async Task Handle(Message message)
{
await SendTypingNotification(message);
var messageBuilder = new StringBuilder();
if (!await IsUserAdmin(message))
{
messageBuilder.AppendLine("Only admins can use this command.");
await Client.SendTextMessageAsync(message.Chat.Id, messageBuilder.ToString(), replyToMessageId : message.MessageId);
return;
}
var parameters = message.Text.Split(" ");
if (parameters.Length == 1)
{
await ShowOptions <GrammarAlgorithms>(message, "Choose Algorithm");
}
else
{
bool parsedOk = int.TryParse(parameters[1], out int algorithm);
if (parsedOk && algorithm.IsAssignableToEnum <GrammarAlgorithms>())
{
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
chatConfig.GrammarAlgorithm = (GrammarAlgorithms)algorithm;
await _chatConfigurationService.Update(chatConfig);
await Client.SendTextMessageAsync(message.Chat.Id, "Algorithm updated.");
}
else
{
await Client.SendTextMessageAsync(message.Chat.Id, $"Invalid parameter. Type {TelegramBotCommands.SetAlgorithm} <algorithm_numer> to set an algorithm.");
}
}
await NotifyIfBotIsNotAdmin(message);
}
public async Task Handle(Message message)
{
await SendTypingNotification(message);
if (!await IsUserAdmin(message))
{
await Client.SendTextMessageAsync(message.Chat.Id, "Only admins can use this command.", replyToMessageId : message.MessageId);
return;
}
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
chatConfig.HideCorrectionDetails = false;
await _chatConfigurationService.Update(chatConfig);
await Client.SendTextMessageAsync(message.Chat.Id, "Show correction details ✅");
await NotifyIfBotIsNotAdmin(message);
}
public async Task Handle(Message message)
{
await SendTypingNotification(message);
if (!await IsUserAdmin(message))
{
await Client.SendTextMessageAsync(message.Chat.Id, "Only admins can use this command.", replyToMessageId : message.MessageId);
return;
}
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
chatConfig.CorrectionStrictnessLevel = CorrectionStrictnessLevels.Intolerant;
await _chatConfigurationService.Update(chatConfig);
await Client.SendTextMessageAsync(message.Chat.Id, "Intolerant ✅");
await NotifyIfBotIsNotAdmin(message);
}
public async Task Handle(Message message)
{
await SendTypingNotification(message);
if (!await IsUserAdmin(message))
{
await Client.SendTextMessageAsync(message.Chat.Id, "Only admins can use this command.", replyToMessageId : message.MessageId);
return;
}
var parameters = message.Text.Split(" ");
if (parameters.Length == 1)
{
await Client.SendTextMessageAsync(message.Chat.Id, $"Parameter not received. Type {TelegramBotCommands.AddWhiteList} <word> to add a Whitelist word.");
}
else
{
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
var word = parameters[1].Trim();
if (chatConfig.WhiteListWords.Contains(word, new CaseInsensitiveEqualityComparer()))
{
await Client.SendTextMessageAsync(message.Chat.Id, $"The word '{word}' is already on the WhiteList");
return;
}
chatConfig.WhiteListWords.Add(word);
await _chatConfigurationService.Update(chatConfig);
await Client.SendTextMessageAsync(message.Chat.Id, $"Word '{word}' added to the WhiteList.");
}
await NotifyIfBotIsNotAdmin(message);
}