private static async void SendTest(CallbackQueryEventArgs e, long chatID) { UserInfo userInfo = userValues[chatID]; var answer = new InlineKeyboardMarkup(new[] { // first row - first answer new [] { InlineKeyboardButton.WithCallbackData($"{Data.Answers[userInfo.QuestionId,0]}", $"answer{userInfo.QuestionId}0") }, // second row - second answer new [] { InlineKeyboardButton.WithCallbackData($"{Data.Answers[userInfo.QuestionId,1]}", $"answer{userInfo.QuestionId}1") }, // third row - third answer new [] { InlineKeyboardButton.WithCallbackData($"{Data.Answers[userInfo.QuestionId,2]}", $"answer{userInfo.QuestionId}2") } }); await botClient.SendTextMessageAsync( chatId : chatID, text : Data.Questions[userInfo.QuestionId], replyMarkup : answer ); if (e != null) { await botClient.EditMessageReplyMarkupAsync(chatID, e.CallbackQuery.Message.MessageId, replyMarkup : null); } }
/// <summary> /// Удаление клавиатуры у предыдущего сообщения /// </summary> /// <param name="callbackQuery"></param> /// <returns></returns> private async Task RemoveKeyboardFromPrevious(CallbackQuery callbackQuery) { await _botClient.EditMessageReplyMarkupAsync( chatId : callbackQuery.Message.Chat.Id, messageId : callbackQuery.Message.MessageId, replyMarkup : null, cancellationToken : Token); }
public async Task ProcessUpdate(ITelegramBotClient client, Update update) { long chatId = update.GetChatId(); if (this.state == State.WaitingForMessageText) { if (update.Type == UpdateType.Message) { this.reminder.MessageText = update.Message.Text; this.state = State.WaitingForTime; await client.SendTextMessageAsync(chatId, $"Reminder text:\n{this.reminder.MessageText}\n\nEnter redinder time. Use 24-hour HHmm format.", replyMarkup : TelegramHelper.GetHomeButtonKeyboard()); } } else if (this.state == State.WaitingForTime) { if (update.Type == UpdateType.Message) { string timeText = update.Message.Text; TimeSpan time; if (TelegramHelper.TryParseTime(timeText, out time)) { this.reminder.DayTime = time; this.state = State.WaitingForWeekDays; await client.SendTextMessageAsync(chatId, "Select reminder week days", replyMarkup : getWeekDaysKeyboard(this.reminder.WeekDays)); } else { await client.SendTextMessageAsync(chatId, "Could not parse time. Use 24-hour HHmm format.", replyMarkup : TelegramHelper.GetHomeButtonKeyboard()); } } } else if (this.state == State.WaitingForWeekDays) { if (update.Type == UpdateType.CallbackQuery) { if (update.CallbackQuery.Data == SelectDaysDone) { await client.AnswerCallbackQueryAsync(update.CallbackQuery.Id); await client.EditMessageReplyMarkupAsync(chatId, update.CallbackQuery.Message.MessageId, TelegramHelper.GetHomeButtonKeyboard()); Program.RemindersRepository.StoreReminder(this.reminder); this.Finished = true; await client.SendDefaultMessageAsync(chatId); } else if (Enum.TryParse(typeof(WeekDays), update.CallbackQuery.Data, out object parsed)) { await client.AnswerCallbackQueryAsync(update.CallbackQuery.Id); WeekDays wdSelected = (WeekDays)parsed; this.reminder.WeekDays ^= wdSelected; await client.EditMessageReplyMarkupAsync(chatId, update.CallbackQuery.Message.MessageId, getWeekDaysKeyboard(this.reminder.WeekDays)); } } } }
/// <inheritdoc/> public async Task <Result> Execute(CallbackQuery callbackQuery, ITelegramBotClient client, IUserManager userManager) { callbackQuery = callbackQuery ?? throw new ArgumentNullException(nameof(callbackQuery)); var callbackData = callbackQuery.Data; var message = callbackQuery.Message; InvitationResponce response; try { response = JsonConvert.DeserializeObject <InvitationResponce>(callbackData); } catch (Exception ex) { return(Result.Failure(new string[] { ex.Message })); } Console.WriteLine($"Answer: {response.Answer} for User Id: {response.ToId}"); var recipient = await userManager.GetUserByIdAsync(response.FromId); var sender = await userManager.GetUserByIdAsync(response.ToId); if (recipient == null || sender == null) { return(null); } switch (response.Answer) { case Answer.Accept: { var recipientText = string.Format(Callback.AnswerSent, sender.Username); var senderText = string.Format(Callback.AcceptInvitation, recipient.Username); await client.SendTextMessageAsync(recipient.Id, $"{recipientText} {Callback.Prepare} \ud83d\udcaa", ParseMode.Default, false, false, 0, replyMarkup : new ReplyKeyboardRemove()); await client.SendTextMessageAsync(sender.Id, $"{senderText} \ud83e\udd1d \ud83d\ude0e {Callback.Prepare} \ud83d\udcaa"); } break; case Answer.Decline: { var recipientText = string.Format(Callback.AnswerSent, sender.Username); var senderText = string.Format(Callback.DeclineInvitation, recipient.Username); await client.SendTextMessageAsync(recipient.Id, $"{recipientText} {Callback.GetReady} \ud83d\udc4c", ParseMode.Default, false, false, 0, replyMarkup : new ReplyKeyboardRemove()); await client.SendTextMessageAsync(sender.Id, $"{senderText} \ud83e\udd2d \ud83d\ude2d {Callback.GetReady} \ud83d\udc4c"); } break; } await client.EditMessageReplyMarkupAsync(message.Chat.Id, message.MessageId, replyMarkup : null); return(Result.Success()); }
public async Task <IEnumerable <IUser> > SelectUsers(long id, IEnumerable <IUser> users, int count) { var tcs = new TaskCompletionSource <IEnumerable <IUser> >(); Message message = null; var selectedUsers = new HashSet <IUser>(); EventHandler <CallbackQueryEventArgs> handler = (s, e) => { if (message.MessageId == e.MessageId) { selectedUsers.Add(users.FirstOrDefault(x => x.Id.ToString() == e.Data)); client .EditMessageReplyMarkupAsync( new ChatId(message.Chat.Id), message.MessageId, new InlineKeyboardMarkup( users .Where(x => !selectedUsers.Contains(x)) .Select(x => new InlineKeyboardButton[] { new InlineKeyboardButton() { Text = x.Name, CallbackData = x.Id.ToString() } }))) .Wait(); if (selectedUsers.Count == count) { tcs.TrySetResult(selectedUsers); } } }; try { callbackQueryHandler.CallbackQuery += handler; message = await client.SendTextMessageAsync( chatId : new Telegram.Bot.Types.ChatId(id), text : string.Format("Please select {0}", count), replyMarkup : new InlineKeyboardMarkup( users.Select(x => new InlineKeyboardButton[] { new InlineKeyboardButton() { Text = x.Name, CallbackData = x.Id.ToString() } }))); var result = await tcs.Task; await client.DeleteMessageAsync(new ChatId(message.Chat.Id), message.MessageId); return(result); } finally { callbackQueryHandler.CallbackQuery -= handler; } }
public async Task <(string text, bool showAlert, string url)> Handle(CallbackQuery data, object context = default, CancellationToken cancellationToken = default) { var callback = data.Data?.Split(':'); if (callback?[0] != ID) { return(null, false, null); } var player = await myDb.Set <Player>().Get(data.From, cancellationToken); switch (callback.Skip(1).FirstOrDefault()?.ToLowerInvariant()) { case Commands.ClearIGN: if (player != null) { player.Nickname = null; await myDb.SaveChangesAsync(cancellationToken); } await myBot.EditMessageReplyMarkupAsync(data, InlineKeyboardMarkup.Empty(), cancellationToken); return("Your IGN is removed", false, null); case Commands.ClearFriendCode: if (player != null) { player.FriendCode = null; await myDb.SaveChangesAsync(cancellationToken); } await myBot.EditMessageReplyMarkupAsync(data, InlineKeyboardMarkup.Empty(), cancellationToken); return("Your Friend Code is removed", false, null); } return(null, false, null); }
public async Task <bool?> Handle(MessageEntityEx entity, PollMessage context = default, CancellationToken cancellationToken = default) { if (!this.ShouldProcess(entity, context, ctx => ctx.Message.From?.Id is {} userId&& mySuperAdministrators.Contains(userId))) { return(null); } var(content, replyMarkup) = await myTimeZoneNotifyService.GetSettingsMessage(entity.Message.Chat, cancellationToken : cancellationToken); var message = await myBot.SendTextMessageAsync(entity.Message.Chat, content, disableNotification : true, replyMarkup : replyMarkup, cancellationToken : cancellationToken); var(_, updatedReplyMarkup) = await myTimeZoneNotifyService.GetSettingsMessage(message.Chat, message.MessageId, cancellationToken); await myBot.EditMessageReplyMarkupAsync(message.Chat, message.MessageId, updatedReplyMarkup, cancellationToken); return(false); // processed, but not pollMessage }
public async Task Handle(RemoveDescriptionCallback notification, CancellationToken ct) { var callback = notification.CallbackQuery; var descriptionId = notification.CallbackData.DescriptionId; var description = await mediator.Send(new GetStickerDescriptionQuery(descriptionId), ct); await mediator.Send(new RemoveStickerDescriptionCommand(descriptionId), ct); var descriptions = await mediator.Send(new GetStickerDescriptionsQuery(description.Sticker.Id), ct); await botClient.EditMessageReplyMarkupAsync( chatId : callback.Message.Chat, messageId : callback.Message.MessageId, replyMarkup : StickerDescriptionButtonsBuilder.BuildDescriptionMarkup(descriptions), cancellationToken : ct); }
public async Task ProcessUpdate(ITelegramBotClient client, Update update) { if (update.Type == UpdateType.CallbackQuery) { long reminderId; if (long.TryParse(update.CallbackQuery.Data, out reminderId)) { await client.AnswerCallbackQueryAsync(update.CallbackQuery.Id); long chatId = update.CallbackQuery.Message.Chat.Id; await client.EditMessageReplyMarkupAsync(chatId, update.CallbackQuery.Message.MessageId, TelegramHelper.GetHomeButtonKeyboard()); Program.RemindersRepository.RemoveReminder(chatId, reminderId); this.Finished = true; await client.SendDefaultMessageAsync(chatId); } } }
public async Task GetUpdates(Update update) { if (update == null) { return; } try { var response = update.Type switch { UpdateType.CallbackQueryUpdate => await HandleNewCallbackQueryAsync(update), UpdateType.MessageUpdate => await HandleNewMessageAsync(update), _ => new Response() }; switch (response.ResponseType) { case ResponseTypeEnum.Photo: await _telegramBotClient.SendPhotoAsync( response.ChatId, new InputOnlineFile(response.ImageStream, "Image.png")); return; case ResponseTypeEnum.UpdateMessage: await _telegramBotClient.EditMessageReplyMarkupAsync(response.ChatId, response.UpdatingMessageId, response.InlineKeyboardMarkup); return; case ResponseTypeEnum.NewMessage: await _telegramBotClient.SendTextMessageAsync(response.ChatId, response.Message, replyToMessageId : response.ReplyToMessageId, replyMarkup : response.InlineKeyboardMarkup ?? response.ReplyKeyboardMarkup, disableWebPagePreview : response.DisableWebPagePreview, parseMode : response.ParseMode); return; case null: throw new Exception("Nothing changed"); default: throw new Exception("Nothing changed"); } } catch (UnauthorizedAccessException) { if (update.CallbackQuery == null) { await _telegramBotClient.SendTextMessageAsync( update.Message.Chat.Id, ErrorResources.AuthorizationError ); } else //in case if user pushed a callback button. { await _telegramBotClient.SendTextMessageAsync( update.CallbackQuery.Message.Chat.Id, ErrorResources.AuthorizationError ); } } }
public static async Task DataSender(CallbackQuery callbackQuery, ITelegramBotClient botClient, bool onEdit) { var id = callbackQuery.From.Id; var firebaseResponse = await client.GetTaskAsync(id.ToString()); if (firebaseResponse.Body != "null") { var newObj = JObject.Parse(firebaseResponse.Body); var list = newObj.Values(); var backButtonRow = new List <InlineKeyboardButton>(); var ikbList = new List <InlineKeyboardButton[]>(); var builder = new StringBuilder(); foreach (var t in list) { var buttonsList = new List <InlineKeyboardButton>(); buttonsList.Add(new InlineKeyboardButton { CallbackData = t["Id"].ToString(), Text = t["Text"].ToString() }); ikbList.Add(buttonsList.ToArray()); builder.Append(t["Text"] + "\n"); } backButtonRow.Add(new InlineKeyboardButton { CallbackData = "Домой", Text = "Домой" }); ikbList.Add(backButtonRow.ToArray()); switch (onEdit) { case false: inlineKeyboard = new InlineKeyboardMarkup(new[] { new[] { InlineKeyboardButton.WithCallbackData("☰"), InlineKeyboardButton.WithCallbackData("Домой") } }); await botClient.EditMessageTextAsync(id.ToString(), callbackQuery.Message.MessageId, "Вот список ваших заметок \n" + builder); await botClient.EditMessageReplyMarkupAsync(callbackQuery.From.Id, callbackQuery.Message.MessageId, replyMarkup : inlineKeyboard); break; case true: inlineKeyboard = new InlineKeyboardMarkup(ikbList); await botClient.EditMessageTextAsync(id.ToString(), callbackQuery.Message.MessageId, "Для удаления нажмите на заметку"); await botClient.EditMessageReplyMarkupAsync(callbackQuery.From.Id, callbackQuery.Message.MessageId, replyMarkup : inlineKeyboard); break; } } else { var noNotesScreenInlineKeyboard = new InlineKeyboardMarkup(new[] { new[] { InlineKeyboardButton.WithCallbackData("Добавить заметку") }, new[] { InlineKeyboardButton.WithCallbackData("Домой") } }); await botClient.EditMessageTextAsync(id.ToString(), callbackQuery.Message.MessageId, "Заметок еще нет......"); await botClient.EditMessageReplyMarkupAsync(callbackQuery.From.Id, callbackQuery.Message.MessageId, replyMarkup : noNotesScreenInlineKeyboard); } }
private void Bot_OnCallbackQuery(object sender, Telegram.Bot.Args.CallbackQueryEventArgs e) { if (!Keyboards.ContainsKey(e.CallbackQuery.From.Id)) { Keyboards[e.CallbackQuery.From.Id] = new UsersKeyboards(); } if (e.CallbackQuery.Data == "_") { botClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id); return; } if (Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForRegistration != null && Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForRegistration.MessageID == e.CallbackQuery.Message.MessageId) { logger.Info("User wants to switch to usuall keyboard for schedule."); Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForRegistration.UpdateKeybordChoosen(e.CallbackQuery.Data); botClient.EditMessageReplyMarkupAsync( chatId: e.CallbackQuery.Message.Chat, messageId: e.CallbackQuery.Message.MessageId, replyMarkup: Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForRegistration.Keyboard ); botClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id); return; } if (e.CallbackQuery.Data == "NextDay" && Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule != null) { UsersInfoForSelectsAndInserts person = new UsersInfoForSelectsAndInserts( chat_id: e.CallbackQuery.Message.Chat.Id.ToString()); string lessons = Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule.NextDay(person); #region EditingMessageWithAnotherDayLessons if (Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule.NextDayMessageID != 0) { botClient.EditMessageTextAsync( chatId: e.CallbackQuery.Message.Chat, messageId: Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule.NextDayMessageID, text: lessons, parseMode: Telegram.Bot.Types.Enums.ParseMode.Html ); } else { Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule.NextDayMessageID = botClient.SendTextMessageAsync( chatId: e.CallbackQuery.Message.Chat, text: lessons, parseMode: Telegram.Bot.Types.Enums.ParseMode.Html).Result.MessageId; } #endregion botClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id); } if (Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule is InlineKeyboardForSchedule && Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule.MessageID == e.CallbackQuery.Message.MessageId) { var keyboard = (InlineKeyboardForSchedule)Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule; switch (e.CallbackQuery.Data) { case "Refresh": logger.Info("User pressed Refresh button."); keyboard.Refresh(); #region DeleteTextMessageWithAnotherDayLessons botClient.DeleteMessageAsync( chatId: e.CallbackQuery.Message.Chat, messageId: Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule.NextDayMessageID); Keyboards[e.CallbackQuery.From.Id].inlineKeyboardForSchedule.NextDayMessageID = 0; #endregion botClient.EditMessageReplyMarkupAsync( chatId: e.CallbackQuery.Message.Chat, messageId: e.CallbackQuery.Message.MessageId, replyMarkup: keyboard.Keyboard ); break; case "NextLesson": logger.Info("User pressed NextLesson button."); keyboard.NextLesson(); botClient.EditMessageReplyMarkupAsync( chatId: e.CallbackQuery.Message.Chat, messageId: e.CallbackQuery.Message.MessageId, replyMarkup: keyboard.Keyboard ); break; } botClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id); return; } }
public async Task <(string text, bool showAlert, string url)> Handle(CallbackQuery data, object context = default, CancellationToken cancellationToken = default) { var callback = data.Data?.Split(':'); if (callback?[0] != ID) { return(null, false, null); } var host = data.From; var player = await myDB.Set <Player>().Get(host, cancellationToken); var command = callback.Skip(1).FirstOrDefault(); var commandParameter = callback.Skip(2).FirstOrDefault(); switch (command) { case Commands.SendCodeId: case Commands.AutoApproveId: case Commands.ApproveSettingsId when bool.TryParse(commandParameter, out var autoApprove) && autoApprove: if (player?.FriendCode == null) { await myFriendshipService.SetupFriendCode(myBot, host, StringSegment.Empty, cancellationToken); return("Please, specify your Friend Code first", true, null); } break; } switch (command) { case Commands.SendCodeId when long.TryParse(commandParameter, out var userId) && long.TryParse(callback.Skip(3).FirstOrDefault(), out var botId): try { if (!myBots.TryGetValue(botId, out var bot)) { bot = myBot; } await myFriendshipService.SendCode(bot, new User { Id = userId }, host, player, cancellationToken); await myBot.EditMessageReplyMarkupAsync(data, InlineKeyboardMarkup.Empty(), cancellationToken); return("Friend Code sent", false, null); } catch (ApiRequestException apiEx) when(apiEx.ErrorCode == 403) { return("User blocked personal messages for the bot.\r\nSend him/her code by yourself.", true, null); } case Commands.AskCodeId when long.TryParse(commandParameter, out var userId) && long.TryParse(callback.Skip(3).FirstOrDefault(), out var botId): try { if (!myBots.TryGetValue(botId, out var bot)) { bot = myBot; } await myFriendshipService.AskCode(host, myBot, new User { Id = userId }, bot, player, cancellationToken); await myBot.EditMessageReplyMarkupAsync(data, InlineKeyboardMarkup.Empty(), cancellationToken); return("Friend Code asked", false, null); } catch (ApiRequestException apiEx) when(apiEx.ErrorCode == 403) { return("User blocked personal messages for the bot.\r\nAsk him/her for the code by yourself.", true, null); } case Commands.ApproveId when int.TryParse(commandParameter, out var userId): await myFriendshipService.ApproveFriendship(host, new User { Id = userId }, cancellationToken); await myBot.EditMessageReplyMarkupAsync(data, InlineKeyboardMarkup.Empty(), cancellationToken); return("He/She marked as already Friend.", false, null); case Commands.AutoApproveId when int.TryParse(commandParameter, out var pollId): var poll = await myDB .Set <Poll>() .Where(_ => _.Id == pollId) .IncludeRelatedData() .FirstOrDefaultAsync(cancellationToken); if (poll == null) { return("Poll is publishing. Try later.", true, null); } var hostVote = poll.Votes.FirstOrDefault(_ => _.UserId == host.Id); if (hostVote == null) { return("Poll is publishing. Try later.", true, null); } hostVote.Team |= VoteEnum.AutoApproveFriend; // approve already awaiting requests foreach (var friendship in await myDB.Set <Friendship>() .Where(f => f.PollId == pollId && (f.Id == host.Id || f.FriendId == host.Id)).ToListAsync(cancellationToken)) { friendship.Type = FriendshipType.Approved; if (poll.Votes.SingleOrDefault(v => (v.UserId == friendship.Id || v.UserId == friendship.FriendId) && v.UserId != host.Id) is { } vote) { try { if (vote.BotId is not { } botId || !myBots.TryGetValue(botId, out var bot)) { bot = myBot; } await myFriendshipService.SendCode(bot, vote.User, host, player, cancellationToken); } catch (ApiRequestException apiEx) when(apiEx.ErrorCode == 403) { // personal messages banned for host - propose user to ask for FC manually } } } await myDB.SaveChangesAsync(cancellationToken); await myBot.EditMessageReplyMarkupAsync(data, InlineKeyboardMarkup.Empty(), cancellationToken); return($"All invitees of `{poll.Title}` will be automatically approved.", false, null); case Commands.ApproveSettingsId: if (player == null) { player = new Player { UserId = host.Id }; myDB.Add(player); } if (bool.TryParse(commandParameter, out var autoApprove)) { player.AutoApproveFriendship = autoApprove; } else { player.AutoApproveFriendship = null; } await myDB.SaveChangesAsync(cancellationToken); await myBot.EditMessageReplyMarkupAsync(data, FriendshipCommandHandler.GetInlineKeyboardMarkup(player), cancellationToken); return("Friendship settings modified", false, null); } return(null, false, null); }
public async Task TickMessage(Message message) { await _bot.EditMessageReplyMarkupAsync(message.Chat, message.MessageId).ConfigureAwait(false); await _bot.EditMessageTextAsync(message.Chat, message.MessageId, "✅" + message.Text).ConfigureAwait(false); }
private static async void OnCallBackQueryReceived(object sender, CallbackQueryEventArgs e) { var buttonText = e.CallbackQuery.Data; var name = $"{e.CallbackQuery.From.FirstName} {e.CallbackQuery.From.LastName}"; var id = e.CallbackQuery.From.Id; try { // await botClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id, $"{name} нажал {buttonText}"); } catch (Telegram.Bot.Exceptions.InvalidParameterException exception) { Console.WriteLine(exception); throw; } var onEdit = false; //Следит за режимом инлайн клавиатуры для редактирования заметки switch (buttonText) { case "Добавить заметку": isAddingMode = true; //Говорит о том что следущее сообщение довавить в бд await botClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, "Ок, сейчас отправь заметку, которую хочешь сохранить "); await botClient.EditMessageReplyMarkupAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, replyMarkup : backlInlineKeyboard); break; case "Отменить": await botClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, WelcomeText); await botClient.EditMessageReplyMarkupAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, replyMarkup : startInlineKeyboard); break; case "Домой": await botClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, WelcomeText); await botClient.EditMessageReplyMarkupAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, replyMarkup : startInlineKeyboard); break; case "Что нового?": var res = $"{await Weather.WeatherSender()}\n{await News.Currency()}"; await botClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, res); await botClient.EditMessageReplyMarkupAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, replyMarkup : backlInlineKeyboard); break; case "Показать список заметок": await Firebase.DataSender(e.CallbackQuery, botClient, onEdit); break; case "☰": onEdit = true; await Firebase.DataSender(e.CallbackQuery, botClient, onEdit); break; case "Установить помидор": await botClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, "Установлен помидор на 2 часа "); await botClient.EditMessageReplyMarkupAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, replyMarkup : pomadoroInlineKeyboard); Pomodoro.IsWorking = true; Pomodoro.Timer(e.CallbackQuery, botClient); break; case "Сбросить помидор": Pomodoro.IsWorking = false; Pomodoro.Timer(e.CallbackQuery, botClient); await botClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id, "Помидор сброшен"); await botClient.SendTextMessageAsync(e.CallbackQuery.From.Id, WelcomeText, replyMarkup : startInlineKeyboard); break; case "Состояние помидора": await botClient.SendTextMessageAsync(e.CallbackQuery.From.Id, $"Прошло {Pomodoro.ReturnTimerStatus()} минут"); break; case "Помидор": await botClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, "Выберите опцию"); await botClient.EditMessageReplyMarkupAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, replyMarkup : pomadoroInlineKeyboard); break; default: await Firebase.DataRemover(e.CallbackQuery); onEdit = true; await Firebase.DataSender(e.CallbackQuery, botClient, onEdit); break; } }