public override sealed void ProcessCommand(TelegramCommand command)
{
if (command.CommandType == TelegramCommandType.ButtonPressed)
{
var c = command as TelegramButtonPressedCommand;
if (c.CallbackData == MainButtonCommand)
{
Done(CheckedOptions);
return;
}
ActiveMessage = new TelegramTextMessageWithKeyboardEdited(LastMessageId, ActiveMessage, clearKeyboard: true);
if (CheckedOptions.Contains(c.CallbackData))
{
CheckedOptions.Remove(c.CallbackData);
}
else
{
CheckedOptions.Add(c.CallbackData);
}
foreach (var pair in ButtonList)
{
if (CheckedOptions.Contains(pair.Value))
{
ActiveMessage.AddCallbackButton(GetCheckedString(pair.Key), pair.Value);
}
else
{
ActiveMessage.AddCallbackButton(GetUncheckedString(pair.Key), pair.Value);
}
}
GenerateMainButtonCommand();
ActiveMessage.AddCallbackButton(MainButton, MainButtonCommand, true);
PostMessage(ActiveMessage);
}
}
public override void ProcessCommand(TelegramCommand command)
{
if (command.CommandType == TelegramCommandType.ButtonPressed)
{
if ((command as TelegramButtonPressedCommand).CallbackData == Callback)
{
if (ActiveMessage.MessageId > 0)
{
Increment++;
ActiveMessage = new TelegramTextMessageWithKeyboardEdited(ActiveMessage.MessageId, ActiveMessage, string.Format(MessageTemplate, Increment));
PostMessage(ActiveMessage);
}
}
}
else if (command.CommandType == TelegramCommandType.Geo)
{
PostMessage(ActiveMessage.GetMessageToHide());
double Latitude = (command as TelegramGeoCommand).Latitude;
double Longitude = (command as TelegramGeoCommand).Longitude;
TelegramTextMessage m = new TelegramTextMessage(UserId, string.Format("{0} {1}", Latitude, Longitude));
PostMessage(m);
}
else
{
Machine.Bot.terminate = true;
}
}
//make from static or ctor
private void FromTelegram(string body)
{
TelegramUpdate update = JsonConvert.DeserializeObject <TelegramUpdate>(body, Utils.ConverterSettingsSnake);
switch (update.Type)
{
case UpdateType.Message:
Id = update.Message.MessageId.ToString();
Text = update.Message.Text;
Payload = "";
User = new User(update.Message.From);
TelegramCommand = new TelegramCommand(update.Message);
break;
case UpdateType.CallbackQuery:
Id = update.CallbackQuery.Message.MessageId.ToString();
Text = "";
Payload = update.CallbackQuery.Data;
User = new User(update.CallbackQuery.From);
TelegramCommand = new TelegramCommand(update.Message);
break;
default:
throw new ArgumentException("This update type is not supported");
}
}
private async Task <OperationResult> SendReply(TelegramCommand commandBase)
{
var gain = await _currencyService.GetCurrencyRateGain(commandBase.Text, DateTime.UtcNow);
var currency = _messageService.GetCurrencyRateMessageAsync(gain);
if (string.IsNullOrWhiteSpace(currency))
{
await MessageSender.SendTextAsync(
new TelegramMessage
{
Keyboard = new ForceReplyMarkup(),
Text = MessagesConstants.CurrencyNotFound,
Receiver = commandBase.ChatId.ToString(),
ReplyToMessageId = commandBase.MessageId
});
}
await MessageSender.SendTextAsync(
new TelegramMessage
{
Keyboard = GetCurrencyRateKeyboard.Keyboard,
Text = currency,
Receiver = commandBase.ChatId.ToString()
});
return(new OperationResult());
}
public override async Task <OperationResult> ExecuteAsync(TelegramCommand commandBase)
{
if (IsSetupMessage(commandBase.Text))
{
return(await MessageSender.SendTextAsync(
new TelegramMessage
{
Keyboard = new ForceReplyMarkup(),
Text = $"{ActionConstants.SetupDefaultCurrencies} \r\n " +
$"{MessagesConstants.SetupDefaultCurrencies}",
Receiver = commandBase.ChatId.ToString(),
ReplyToMessageId = commandBase.MessageId
}));
}
await _usersService.SetUserDefaultCurrencies(commandBase.SenderUsername, commandBase.Text);
return(await MessageSender.SendTextAsync(
new TelegramMessage
{
Keyboard = GetCurrencyRateKeyboard.Keyboard,
Text = MessagesConstants.SetupDefaultCurrenciesSuccess,
Receiver = commandBase.ChatId.ToString()
}));
}
/// <inheritdoc />
public virtual ValueTask HandleCommandErrorAsync(ITelegramBotClient client, TelegramCommand command, Exception e,
CancellationToken ct)
{
var logger = _loggerFactory.CreateLogger(command.GetType());
logger.LogError(e, "Error occurred while handling telegram bot command.");
return(new ValueTask());
}
public override async Task <OperationResult> ExecuteAsync(TelegramCommand commandBase)
{
return(await MessageSender.SendTextAsync(new TelegramMessage
{
Receiver = commandBase.ChatId.ToString(),
Keyboard = GetCurrencyRateKeyboard.Keyboard,
Text = MessagesConstants.Hello
}));
}
public void Should_create_command_from_an_invalid_command(string input)
{
var textMessage = UnitTestHelper.CreateTelegramTextMessage(input);
var command = new TelegramCommand(textMessage);
command.IsCommand.Should().BeFalse();
command.Message.Text.Should().Be(input);
command.Args.Should().BeNullOrEmpty();
command.Rest.Should().BeNullOrEmpty();
command.CommandName.Should().BeNullOrEmpty();
}
public async Task ExecuteActionAsync_NotExistedCommand_CommandNotFount()
{
var actionExecutor = GetService <IActionExecutor <TelegramCommand> >();
var command = new TelegramCommand("Not existed");
var result = await actionExecutor.ExecuteActionAsync(command);
Assert.False(result.Success);
Assert.AreEqual(Constants.CommandNotFound, result.Error);
}
public void TelegramMessageReceiver(string message)
{
var messageFractions = message.Split(' ');
if (messageFractions.Length < 1)
{
return;
}
var cmd = new TelegramCommand
{
Command = messageFractions[0],
Args = messageFractions.Where((x, i) => i > 0).ToArray(),
Time = DateTime.Now
};
}
public void Should_create_command_from_a_valid_command(string input, string expectedCommand,
string expectedRest, params string[] expectedArgs)
{
var textMessage = UnitTestHelper.CreateTelegramTextMessage(input);
var command = new TelegramCommand(textMessage);
command.IsCommand.Should().BeTrue();
command.Message.Text.Should().Be(textMessage.Text);
command.CommandName.Should().Be(expectedCommand);
command.Rest.Should().Be(expectedRest);
command.Args.Should().HaveCount(expectedArgs.Length);
foreach (var(arg, i) in command.Args.Select((v, i) => (v, i)))
{
arg.Should().Be(expectedArgs[i]);
}
}
private async Task TryParseAsCommand(TelegramTextMessage textMessage)
{
var command = new TelegramCommand(textMessage);
if (!command.IsCommand)
{
return;
}
var applicableExecutors = _commandExecutors.Where(c => c.CanExecute(command));
foreach (var commandExecutor in applicableExecutors)
{
await commandExecutor.ExecuteCommand(command);
}
}
public override async Task <OperationResult> ExecuteAsync(TelegramCommand commandBase)
{
if (commandBase.Text?.Length == 3)
{
return(await SendReply(commandBase));
}
return(await MessageSender.SendTextAsync(
new TelegramMessage
{
Keyboard = new ForceReplyMarkup(),
Text = $"{ActionConstants.GetConcreteCurrencyRateAction} \r\n " +
$"{MessagesConstants.YouChooseConcreteCurrency}",
Receiver = commandBase.ChatId.ToString(),
ReplyToMessageId = commandBase.MessageId
}));
}
public void TelegramCommandReceiver(string sender, string command, long chatId, string[] args)
{
if (!CheckOwner(sender))
{
return;
}
var cmd = new TelegramCommand
{
Sender = sender,
Command = command,
Args = args ?? new string[0],
ChatId = chatId,
Time = DateTime.Now
};
_commandsQueue.Enqueue(cmd);
}
public async Task ExecuteActionAsync_CorrectCommand_SuccessfullyResult()
{
var actionExecutor = GetService <IActionExecutor <TelegramCommand> >();
var command = new TelegramCommand(nameof(TestAction)
.Replace(TestConstants.Action, string.Empty))
{
ChatId = 1,
Text = string.Empty,
MessageId = 1,
SenderUsername = "******",
UserId = 1
};
var result = await actionExecutor.ExecuteActionAsync(command);
Assert.True(result.Success);
Assert.AreEqual("", result.Error);
}
public void CanExecute_returns_false_if_command_is_not_a_command()
{
var executor = new EchoCommandExecutor(null, null);
var command = new TelegramCommand(
TelegramTextMessage.Create(
TelegramMessage.Create(
new TelegramUpdate
{
Message = new Message {
Text = ""
}
})));
command.IsCommand.Should().BeFalse();
var result = executor.CanExecute(command);
result.Should().BeFalse();
}
public override async Task <OperationResult> ExecuteAsync(TelegramCommand command)
{
var user = await _usersService.GetUserByUsernameAsync(command.SenderUsername);
if (user == null)
{
user = await _usersService.CreateUserAsync(new User
{
TelegramId = command.UserId,
Username = command.SenderUsername
});
}
return(await MessageSender.SendTextAsync(new TelegramMessage
{
Receiver = command.ChatId.ToString(),
Keyboard = GetCurrencyRateKeyboard.Keyboard,
Text = $"{MessagesConstants.Hello} {user.Username}"
}));
}
public override async Task <OperationResult> ExecuteAsync(TelegramCommand command)
{
var count = await _currencyService.GetCurrenciesCountAsync();
var currencies = await _currencyService.GetAllCurrencies();
var pageCount = Math.Ceiling((double)count / PageSize);
for (var i = 0; i < pageCount; i++)
{
var currentCurrencies = currencies.Skip(PageSize * i).Take(PageSize);
var message = _messageService.GetAllCurrenciesMessageAsync(currentCurrencies);
await MessageSender.SendTextAsync(new TelegramMessage
{
Receiver = command.ChatId.ToString(),
Keyboard = GetCurrencyRateKeyboard.Keyboard,
Text = message
});
}
return(new OperationResult());
}
private void Dispatch(TelegramCommand command)
{
if (!IsException(command))
{
if (MachineExists(command.UserId))
{
if (command.CommandType == TelegramCommandType.TextEntered && (command as TelegramTextCommand).Text.ToLower() == "/start")
{
KillMachine(command.UserId);
CreateMachine(command.UserId);
}
else
{
Machines[command.UserId].ProcessCommand(command);
}
}
else
{
CreateMachine(command.UserId);
}
}
}
public override async Task <OperationResult> ExecuteAsync(TelegramCommand command)
{
var defaultCurrencies = await _usersService.GetUserDefaultCurrencies(command.SenderUsername);
if (!defaultCurrencies.Any())
{
defaultCurrencies = new List <Currency>
{
new Currency {
Abbreviation = "USD"
},
new Currency {
Abbreviation = "EUR"
},
new Currency {
Abbreviation = "RUB"
}
}
}
;
var sb = new StringBuilder();
foreach (var currency in defaultCurrencies)
{
var gain = await _currencyService.GetCurrencyRateGain(currency.Abbreviation, DateTime.UtcNow);
sb.Append(_messageService.GetCurrencyRateMessageAsync(gain));
}
return(await MessageSender.SendTextAsync(new TelegramMessage
{
Receiver = command.ChatId.ToString(),
Keyboard = GetCurrencyRateKeyboard.Keyboard,
Text = sb.ToString()
}));
}
}
protected override bool IsException(TelegramCommand command)
{
return(false);
}
public override Task <OperationResult> ExecuteAsync(TelegramCommand commandBase)
{
return(Task.FromResult(new OperationResult()));
}
/// <summary> /// Returns true if something is changed and it is required to get new state and new message /// </summary> public abstract void ProcessCommand(TelegramCommand command);
protected abstract bool IsException(TelegramCommand command);
private static async Task TelegramMessage(TelegramFSMBot bot, Message message)
{
if (message.Type == MessageType.Text)
{
if (Regex.IsMatch(message.Text, PARAMETRIC_COMMAND_PALETTE))
{
string ParametricCommand = Regex.Match(message.Text, PARAMETRIC_COMMAND_PALETTE).Groups[1].Value;
bot.ReceiveParametricStart(new ParametricStartEventArgs()
{
ParametricCommand = ParametricCommand, UserId = message.From.Id
});
return;
}
TelegramTextCommand command = new TelegramTextCommand(message.From.Id, message.Text);
bot.Dispatch(command);
}
if (message.Type == MessageType.Photo || message.Type == MessageType.Document)
{
MemoryStream ms = new MemoryStream();
string FileName = null;
TelegramCommand command = null;
switch (message.Type)
{
case MessageType.Photo:
bot.GetInfoAndDownloadFileAsync(message.Photo.Last().FileId, ms).Wait();
ms.Seek(0, SeekOrigin.Begin);
command = new TelegramPhotoCommand(message.From.Id, ms.ToArray());
break;
case MessageType.Document:
if (message.Document.FileSize < 19922944)
{
if (bot.AnswerToFilesWithType)
{
bot.Sender.Enqueue(new TelegramTypingMessage(message.From.Id));
}
bot.GetInfoAndDownloadFileAsync(message.Document.FileId, ms).Wait();
ms.Seek(0, SeekOrigin.Begin);
FileName = message.Document.FileName;
command = new TelegramFileCommand(message.From.Id, ms.ToArray(), FileName);
}
else
{
FileTooBigEventArgs ftbea = new FileTooBigEventArgs(message.Chat.Id, message.From.Id, message.MessageId, message.Document.FileName, message.Document.FileId, message.Document.FileSize);
EventHandler <FileTooBigEventArgs> handler = bot.FileTooBig;
handler.Invoke(bot, ftbea);
command = new TelegramEmptyCommand(message.From.Id);
}
break;
}
bot.Dispatch(command);
}
if (message.Type == MessageType.SuccessfulPayment)
{
string InvoiceId = message.SuccessfulPayment.InvoicePayload;
PaymentEventArgs pea = new PaymentEventArgs(InvoiceId);
EventHandler <PaymentEventArgs> handler = bot.PaymentReceived;
handler.Invoke(bot, pea);
}
if (message.Type == MessageType.ChatMembersAdded)
{
Console.WriteLine(message.NewChatMembers);
}
if (message.Type == MessageType.Location || (message.Type == MessageType.Venue && message.Location != null))
{
double[] coords = new double[2];
coords[0] = message.Location.Latitude;
coords[1] = message.Location.Longitude;
TelegramGeoCommand command = new TelegramGeoCommand(message.From.Id, coords);
bot.Dispatch(command);
}
}
public void ProcessCommand(TelegramCommand command)
{
ActiveState.ProcessCommand(command);
}
