private async void BotClientOnOnCallbackQuery(object sender, CallbackQueryEventArgs e)
{
try
{
await _botClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id);
lock (_answerredQueries)
{
_answerredQueries.Where(a => DateTime.UtcNow.AddMinutes(-5) > a.Value)
.ToList()
.ForEach(a => _answerredQueries.Remove(a.Key));
if (e.CallbackQuery.Message.Date < DateTime.UtcNow.AddMinutes(-5))
{
return;
}
if (_answerredQueries.ContainsKey(e.CallbackQuery.Message.MessageId))
{
return;
}
_answerredQueries.Add(e.CallbackQuery.Message.MessageId, DateTime.UtcNow);
}
await _conversationManager[e.CallbackQuery.From.Id].OnCallbackQueryAsync(e);
}
catch (Exception ex)
{
_logger.LogError("BotClientOnOnCallbackQuery failed: {Message} {StackTrace}",
ex.Message, ex.StackTrace);
}
}
private void BotClient_OnCallbackQueryBomb(object sender, CallbackQueryEventArgs e)
{
var bot = (TelegramBotClient)sender;
bot.OnCallbackQuery -= BotClient_OnCallbackQueryBomb;
switch (e.CallbackQuery.Data)
{
case "1":
BComm(e.CallbackQuery.From.Id, Direction.North);
break;
case "2":
BComm(e.CallbackQuery.From.Id, Direction.West);
break;
case "3":
BComm(e.CallbackQuery.From.Id, Direction.East);
break;
case "4":
BComm(e.CallbackQuery.From.Id, Direction.South);
break;
default:
bot.SendTextMessageAsync(e.CallbackQuery.Message.Chat.Id,
"Выбирайте направление а не пустые кнопки");
break;
}
}
public async Task ShowOffersCallBack(CallbackQueryEventArgs callback)
{
long chatid = callback.CallbackQuery.Message.Chat.Id;
ShowOrdersDTO order = await provider.showOrderService.CurrentProduct(chatid);
int currProductId = order.CurrentProductId;
BuisnessTaskDTO task = await provider.buisnessTaskService.FindTaskByTaskId(currProductId);
if (task == null)
{
throw new System.Exception("task cannot be null");
}
List <UserDTO> offers = await provider.offerService.GetUsersOffer(currProductId);
if (offers.Count == 0)
{
await client.SendTextMessageAsync(chatid, "Вам не поступало заявлений");
return;
}
offers.ForEach(async(item) =>
{
string message = $"ChatId пользователя: {item.ChatId}\n " +
$"Телефон:{item.FIO}";
await client.SendTextMessageAsync(chatid, message, 0, false, false, 0, KeyBoardHandler.InviteUserToDialog());
});
}
private async void BotOnCallbackQueryReceived(object sender, CallbackQueryEventArgs e)
{
await _bot.AnswerCallbackQueryAsync(e.CallbackQuery.Id,
"Received" + e.CallbackQuery.Data);
await CheckMessage(e.CallbackQuery.Data);
}
private static async void BotOnCallbackQuerryReceived(object sender, CallbackQueryEventArgs e)
{
var callbackQuery = e.CallbackQuery;
string[] data = callbackQuery.Data.Split(',');
switch (data[0])
{
case "newInit":
if (data[1] == "true")
{
InitChat(callbackQuery.Message);
}
else if (data[1] == "false")
{
await botClient.SendTextMessageAsync(
chatId : callbackQuery.Message.Chat,
text : "Ok, your configuration will remain as it is."
);
}
break;
case "firstInit":
if (data[1] == "ready")
{
InitChat(callbackQuery.Message);
}
break;
default:
break;
}
}
public static async void OnCallbackQuery(object sender, CallbackQueryEventArgs e)
{
foreach (var per in service.GetServices <IOnCallbackQuery>())
{
await per.ExecuteAsync(sender, e);
}
}
public async void OnCallbackQueryAsync(object sender, CallbackQueryEventArgs e)
{
try
{
var callbackData = e.CallbackQuery.Data;
if (string.IsNullOrEmpty(callbackData))
{
return;
}
if (Callback.GetCallbackName(callbackData) == PlayerSetCallback.Name)
{
await DetermineIfUserIsReadyToPlayAsync(e.CallbackQuery);
}
if (Callback.GetCallbackName(callbackData) == TeamPollCallback.Name)
{
await DetermineIfUserLikesTeamAsync(e.CallbackQuery);
}
_logger.Information($"Processed callback: {e.CallbackQuery.Data}");
}
catch (Exception ex)
{
await ProcessCallbackError(e.CallbackQuery, ex);
}
}
public async void SendMessageCalories(CallbackQueryEventArgs e, TelegramBotClient client, long id, string goal)
{
var user = DB.Users.Find(id);
if (user.Language == "Russian")
{
await client.SendTextMessageAsync(e.CallbackQuery.From.Id, $"Для {goal}:\n" +
$"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{user.Calories} калорий каждый день\n" +
$"из которых:\n" +
$"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{user.Proteins} грамм белка\n" +
$"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{user.Fats} грамм жиров\n" +
$"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{user.Carbohydrates} грамм углеводов\n" +
$"напиши\n/addfood [название] [вес] - чтобы добавить еду");
}
else
{
await client.SendTextMessageAsync(e.CallbackQuery.From.Id, $"For {goal}:\n" +
$"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{user.Calories} calories per day\n" +
$"of which:\n" +
$"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{user.Proteins} grams proteins\n" +
$"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{user.Fats} grams fats\n" +
$"\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t{user.Carbohydrates} grams carbohydrates\n" +
$"write\n/addfood [name] [weight] - to add food");
}
}
public static void CallbackQuery(CallbackQueryEventArgs e, ITelegramBotClient bot)
{
string message = e.CallbackQuery.Data;
var chatId = e.CallbackQuery.From.Id;
int id = 0;
int.TryParse(message.Substring(6), out id);
AdminBot.adminLog(message);
Participant participant;
using (MobileContext db = new MobileContext())
{
try
{
var booking = db.Bookings.Single(c => c.Id == id);
var bookingsWeek = db.Bookings.Remove(booking);
db.SaveChanges();
} catch (InvalidOperationException ex)
{
_ = bot.SendTextMessageAsync(chatId, "Бронь уже удалена").Result;
return;
}
participant = db.Participants.Single(c => c.Alias == e.CallbackQuery.From.Username);
}
using (FileStream fs = FormSchedule.FormScheduleImage(participant))
{
Message mes = bot.SendPhotoAsync(chatId: chatId, photo: new InputOnlineFile(fs, "schedule.png"), caption: "Бронь отменена.").Result;
}
}
//Refresh weather
public async Task Info(CallbackQueryEventArgs callbackQueryEventArgs)
{
//Simulate work
await Task.Delay(1000);
var weather = "The weather now is: " + "⛈🌧❄️☀️☁️"[new Random().Next(4)].ToString();
//weather = "The weather now is: ";
weather += $"\n`{DateTime.Now}`";
weather += "\n@nameYourBot_bot";
//Buttons menu
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData("Refresh", $"{Commands.RefreshWeather}?{Commands.IsEdit}=true") //Thats is template how to pack commands with arguments
}
});
//Check if clicked button "Refresh"
var args = ArgParser.ParseCallbackData(callbackQueryEventArgs.CallbackQuery.Data);
bool isEdit = args.ContainsKey(Commands.IsEdit);
if (isEdit)
{
EditMessageTextAsync(ChatId, MessageId, weather, ParseMode.Markdown, replyMarkup: inlineKeyboard);
}
else
{
SendMessage(ChatId, weather, ParseMode.Markdown, replyMarkup: inlineKeyboard);
}
}
private static async void BotClient_OnCallbackQuery(object sender, CallbackQueryEventArgs e)
{
if (e.CallbackQuery.Message.Date < DateTime.Now.AddDays(-1))
{
return;
}
await Task.Run(() => CacheData.IncrementHandledMessages());
if (CacheData.Groups[e.CallbackQuery.Message.Chat.Id].State !=
Models.Group.TelegramGroup.Status.Active)
{
return;
}
Data.Utils.Logging.AddLog(new Models.SystemLog()
{
LoggerName = CacheData.LoggerName,
Date = DateTime.Now,
Function = "Unifiedban.Bot.Manager.BotClient_OnCallbackQuery",
Level = Models.SystemLog.Levels.Debug,
Message = "CallbackQuery received",
UserId = -1
});
if (!String.IsNullOrEmpty(e.CallbackQuery.Data))
{
if (e.CallbackQuery.Data.StartsWith('/'))
{
await Task.Run(() => Command.Parser.Parse(e.CallbackQuery));
}
}
return;
}
async void BotOnCallbackQueryReceived(object sender, CallbackQueryEventArgs callbackQueryEventArgs)
{
using var db = new ApplicationContext();
var callbackQuery = callbackQueryEventArgs.CallbackQuery;
var exchangeRatedb = db.MyfinByExchangeRates.OrderByDescending(x => x.DateTimeRates).FirstOrDefault();
var avUSD = Math.Round((exchangeRatedb.RateUSDbuy + exchangeRatedb.RateUSDsales) / 2, 4);
var avEUR = Math.Round((exchangeRatedb.RateEURbuy + exchangeRatedb.RateEURsales) / 2, 4);
var avRUS = Math.Round((exchangeRatedb.RateRUSbuy + exchangeRatedb.RateRUSsales) / 2, 4);
var answer = (callbackQuery.Data.Split(" ")[0], double.Parse(callbackQuery.Data.Split(" ")[1])) switch
{
("🇺🇸", var v) => $"{v} 🇺🇸 = \n" +
$"{Math.Round(v * avUSD, 2)} 🇧🇾 \n" +
$"{Math.Round(v * avUSD / avEUR, 2)} 🇪🇺 \n" +
$"{Math.Round(v * avUSD / avRUS * 100, 2)} 🇷🇺",
("🇪🇺", var v) => $"{v} 🇪🇺 = \n" +
$"{Math.Round(v * avEUR, 2)} 🇧🇾 \n" +
$"{Math.Round(v * avEUR / avUSD, 2)} 🇺🇸 \n" +
$"{Math.Round(v * avEUR / avRUS * 100, 2)} 🇷🇺",
("🇷🇺", var v) => $"{v} 🇷🇺 = \n" +
$"{Math.Round(v * avRUS / 100, 2)} 🇧🇾 \n" +
$"{Math.Round(v * avRUS / avUSD / 100, 2)} 🇺🇸 \n" +
$"{Math.Round(v * avRUS / avEUR / 100, 2)} 🇪🇺",
("🇧🇾", var v) => $"{v} 🇧🇾 = \n" +
$"{Math.Round(v / avUSD, 2)} 🇺🇸 \n" +
$"{Math.Round(v / avEUR, 2)} 🇪🇺 \n" +
$"{Math.Round(v / avRUS * 100, 2)} 🇷🇺",
_ => throw new NotImplementedException(),
};
private void OnCallbackQuery(object sender, CallbackQueryEventArgs e)
{
ITelegramBotClient telegramBotClient = ModulesManager.GetTelegramBotClient();
if (string.IsNullOrEmpty(e.CallbackQuery.Data))
{
return;
}
string[] queryArray = e.CallbackQuery.Data.Split(":");
if (queryArray.Length == 0)
{
return;
}
ICallbackQueryHandler callbackQueryHandler;
switch (queryArray[0])
{
case "delete_message":
callbackQueryHandler = new DeleteMessageHandler();
break;
default:
return;
}
callbackQueryHandler.Handle(queryArray, e.CallbackQuery.Message.MessageId);
telegramBotClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id);
}
public async void Bot_CallBack(object sender, CallbackQueryEventArgs e)
{
var text = "";
var id = e.CallbackQuery.Message.Chat.Id;
var chat = trainingChats[id];
switch (e.CallbackQuery.Data)
{
case "rustoeng":
training.Add(id, TrainingType.RusToEng);
text = chat.GetTrainingWord(TrainingType.RusToEng);
break;
case "engtorus":
training.Add(id, TrainingType.EngToRus);
text = chat.GetTrainingWord(TrainingType.EngToRus);
break;
default:
break;
}
chat.IsTraningInProcess = true;
activeWord.Add(id, text);
if (trainingChats.ContainsKey(id))
{
trainingChats.Remove(id);
}
await botClient.SendTextMessageAsync(id, text);
await botClient.AnswerCallbackQueryAsync(e.CallbackQuery.Id);
}
private async void OnCallbackQuery(object sender, CallbackQueryEventArgs e)
{
var message = e.CallbackQuery.Message;
var chat = message.Chat;
var parts = e.CallbackQuery.Data.Split('_');
if (parts.Length != 2)
{
return;
}
if (parts[0] == "Office")
{
var officeId = long.Parse(parts[1]);
using (var scope = _serviceProvider.CreateScope())
{
var persistence = scope.ServiceProvider.GetRequiredService <Persistence>();
var office = await persistence.SetUserToOffice(chat.Id, officeId);
await _telegramClient.SendTextMessageAsync(chat.Id, "Вы добавлены в чат: " + office.Name);
}
}
await _telegramClient.DeleteMessageAsync(chat.Id, message.MessageId);
}
private static void BotOnCallbackQueryRecieved(object sender, CallbackQueryEventArgs e)
{
string buttonText = e.CallbackQuery.Data;
string name = $"{e.CallbackQuery.From.FirstName} {e.CallbackQuery.From.LastName}";
Console.WriteLine($"{name} press a key {buttonText}");
}
static async void BotOnCallbackQueryReceived(object sender, CallbackQueryEventArgs callbackQueryEventArgs)
{
var callbackQuery = callbackQueryEventArgs.CallbackQuery;
await Bot.AnswerCallbackQueryAsync(
callbackQueryId : callbackQuery.Id,
text : $"ID {callbackQuery.Data}"
);
var resMovie = await Request.FindMovieById(callbackQuery.Data);
var buttons = new List <InlineKeyboardButton>();
for (int i = 0; i < resMovie.data.movie.torrents.Count; i++)
{
buttons.Add(new InlineKeyboardButton {
Text = $"{resMovie.data.movie.torrents[i].type} {resMovie.data.movie.torrents[i].quality}",
Url = resMovie.data.movie.torrents[i].url
});
}
await Bot.SendPhotoAsync(
chatId : callbackQuery.Message.Chat.Id,
photo : resMovie.data.movie.large_cover_image,
caption : resMovie.data.movie.description_full,
replyMarkup : new InlineKeyboardMarkup(buttons.ToArray())
);
}
public ListChannelsInstruction(ITelegramBotClient telegramBotClient, CallbackQueryEventArgs callbackQueryEventArgs, BotPlatform botPlatform)
{
_telegramBotClient = telegramBotClient;
_callbackQueryEventArgs = callbackQueryEventArgs;
_queryChannelService = botPlatform.Resolve <IQueryChannelService>();
_queryRssChatService = botPlatform.Resolve <IQueryRssChatRelationService>();
}
private void bot_OnCallbackQuery(object sender, CallbackQueryEventArgs e)
{
if (e.CallbackQuery.Message.MessageId != freshBoard)
{
return;
}
if (!hp.ContainsKey(e.CallbackQuery.From.Username))
{
bot.AnswerCallbackQueryAsync(e.CallbackQuery.Id, "Ты не участвуешь");
return;
}
var choice = e.CallbackQuery.Message.ReplyMarkup;
string c = e.CallbackQuery.Data;
Thread.Sleep(700);
if (x == 0)
{
if (e.CallbackQuery.From.Username == p1)
{
act1 = e.CallbackQuery.Data;
}
else if (e.CallbackQuery.From.Username == p2)
{
act2 = e.CallbackQuery.Data;
}
bot.AnswerCallbackQueryAsync(e.CallbackQuery.Id, $"Вы выбрали {e.CallbackQuery.Data}");
if (act1.Length > 0 && act2.Length > 0)
{
bot.EditMessageTextAsync(e.CallbackQuery.Message.Chat.Id, e.CallbackQuery.Message.MessageId, "Защита", replyMarkup: KeyboatdToDeffend(choice));
}
Thread.Sleep(300);
}
else if (x == 1)
{
Thread.Sleep(300);
if (e.CallbackQuery.From.Username == p1)
{
def1 = e.CallbackQuery.Data;
}
else if (e.CallbackQuery.From.Username == p2)
{
def2 = e.CallbackQuery.Data;
}
bot.AnswerCallbackQueryAsync(e.CallbackQuery.Id, $"Вы выбрали {e.CallbackQuery.Data}");
if (def1.Length > 0 && def2.Length > 0)
{
Thread.Sleep(600);
bot.DeleteMessageAsync(e.CallbackQuery.Message.Chat.Id, freshBoard);
BattleRes(act1, def2, p2);
BattleRes(act2, def1, p1);
act1 = "";
def1 = act1;
act2 = act1;
def2 = act1;
Thread.Sleep(800);
Start();
}
}
}
public override void Execute(CallbackQueryEventArgs e, TelegramBotClient client, long id)
{
var user = DB.Users.Find(id);
var callbackQuery = e.CallbackQuery;
if (callbackQuery.Data == "normaly")
{
user.Calories = (int)(user.Calories * 0.90);
user.Goal = "normaly";
}
else if (callbackQuery.Data == "quickly")
{
user.Calories = (int)(user.Calories * 0.75);
user.Goal = "quickly";
}
else if (callbackQuery.Data == "extremely")
{
user.Calories = (int)(user.Calories * 0.59);
user.Goal = "extremely";
}
user.Proteins = (int)((user.Calories * 0.3) / 4 + 1);
user.Fats = (int)((user.Calories * 0.3) / 9 + 1);
user.Carbohydrates = (int)((user.Calories * 0.4) / 4 + 1);
user.Command = " ";
user.SetCalories();
if (callbackQuery.Data == "normaly")
{
if (user.Language == "Russian")
{
SendMessageCalories(e, client, id, "безопасной потери веса");
}
else
{
SendMessageCalories(e, client, id, $"weight loss {user.Goal}");
}
}
else if (callbackQuery.Data == "quickly")
{
if (user.Language == "Russian")
{
SendMessageCalories(e, client, id, "быстрой потери веса");
}
else
{
SendMessageCalories(e, client, id, $"weight loss {user.Goal}");
}
}
else if (callbackQuery.Data == "extremely")
{
if (user.Language == "Russian")
{
SendMessageCalories(e, client, id, "потери веса екстремально быстро");
}
else
{
SendMessageCalories(e, client, id, $"weight loss {user.Goal}");
}
}
}
private static async void Bot_OnCallbackQueryReceived(object sender, CallbackQueryEventArgs e)
{
string buttonText = e.CallbackQuery.Data;
string name = $"{e.CallbackQuery.From.FirstName}{e.CallbackQuery.From.LastName}";
Console.WriteLine($"{name} нажал(а) кнопку {buttonText}");
await Bot.AnswerCallbackQueryAsync(e.CallbackQuery.Id, $"Ты нажал(а) кнопку {buttonText}");
}
private static async void BotOnCallbackQueryReceived(object sender, CallbackQueryEventArgs callbackQueryEventArgs)
{
var callbackQuery = callbackQueryEventArgs.CallbackQuery;
await botClient.AnswerCallbackQueryAsync(callbackQuery.Id, $"Selecionado {callbackQuery.Data}");
Versao = callbackQuery.Data.ToLower();
}
private static async void BotOnCallbackQueryReceived(object sender, CallbackQueryEventArgs callbackQueryEventArgs)
{
var callbackQuery = callbackQueryEventArgs.CallbackQuery;
await Bot.SendTextMessageAsync(
callbackQuery.Message.Chat.Id,
$"Received {callbackQuery.Data}");
}
private static void _telegramBotClient_OnCallbackQuery(object sender, CallbackQueryEventArgs e)
{
IInstruction onCallBackQueryInstruction = new OnCallBackQueryNextInstruction(_telegramBotClient, e, _botplatform);
onCallBackQueryInstruction.Execute();
GC.Collect();
}
Task ParseToContact(MessageEventArgs messageArgs, CallbackQueryEventArgs callbackArgs)
{
_toContact = messageArgs?.Message?.Contact;
ValidateToContact();
return(Task.CompletedTask);
}
public Task OnCallbackQueryAsync(CallbackQueryEventArgs e)
{
_user = e.CallbackQuery.Message.From;
return(BotClient.EditMessageReplyMarkupAsync(
e.CallbackQuery.Message.Chat.Id, e.CallbackQuery.Message.MessageId, null)
.ContinueWith(_ => ProcessMessageAsync(e.CallbackQuery.Data, e.CallbackQuery.Message)));
}
public static async void Spiner(ITelegramBotClient botClient, CallbackQueryEventArgs eventArgs)
{
try
{
await botClient.AnswerCallbackQueryAsync(eventArgs.CallbackQuery.Id);
}
catch { }
}
private static void OnCallbackQuery(object sender, CallbackQueryEventArgs callbackQueryEventArgs)
{
var callbackQuery = callbackQueryEventArgs.CallbackQuery;
var callback = BotCallbackFactory.Get(callbackQuery.Data.ParseType(), bot);
callback?.Execute(callbackQuery);
}
private static void BotOnCallbackQueryReceived(object sender, CallbackQueryEventArgs callbackQueryEvent)
{
var callbackQuery = callbackQueryEvent.CallbackQuery;
var message = callbackQuery.Message;
CommandsExecuter commandsExecuter = new CommandsExecuter(message, telegramBot, callbackQuery);
commandsExecuter.Execute(callbackQuery.Data);
}
public Add_Group_Rss_Instruction(ITelegramBotClient telegramBotClient, CallbackQueryEventArgs callbackQueryEventArgs, BotPlatform botPlatform)
{
_telegramBotClient = telegramBotClient;
_callbackQueryEventArgs = callbackQueryEventArgs;
_commandRssChatService = botPlatform.Resolve <ICommandRssChatRelationService>();
_queryChannelService = botPlatform.Resolve <IQueryChannelService>();
_queryRssService = botPlatform.Resolve <IQueryRssService>();
}
