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;
}
}