public static IEnumerable <InlineKeyboardButton[]> GetInlineKeyboard(IReadOnlyList <string> stringArray)
{
var rows = stringArray.Count / 4;
var haveMod = false;
var columns = 4;
var mod = stringArray.Count % 4;
if (mod != 0)
{
rows++;
haveMod = true;
}
var k = 0;
var keyboardInline = new InlineKeyboardButton[rows][];
for (var i = 0; i < rows; i++)
{
InlineKeyboardButton[] keyboardButton;
if (i == rows - 1 && haveMod)
{
keyboardButton = new InlineKeyboardButton[mod];
columns = mod;
}
else
{
keyboardButton = new InlineKeyboardButton[4];
}
for (var j = 0; j < columns; j++)
{
keyboardButton[j] = InlineKeyboardButton.WithCallbackData(stringArray[k]);
k++;
}
keyboardInline[i] = keyboardButton;
}
return(keyboardInline);
}
private static async void Bot_OnMessage(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
var message = e.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
var name = message.From.FirstName;
Console.WriteLine(message.Text + " от " + name);
switch (message.Text)
{
case "/start":
var text = "Команда для вызова меню - /menu";
await Bot.SendTextMessageAsync(e.Message.From.Id, text);
break;
case "/menu":
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new[]
{
InlineKeyboardButton.WithUrl("Кинопоиск", "https://www.kinopoisk.ru/"),
InlineKeyboardButton.WithUrl("IMDb", "https://www.imdb.com/")
},
new[]
{
InlineKeyboardButton.WithCallbackData("Поиск случайного фильма")
}
});
await Bot.SendTextMessageAsync(message.From.Id, "Выбери пункт меню", replyMarkup : inlineKeyboard);
break;
default:
break;
}
}
static async Task StartMessage(Message message)
{
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new[] { InlineKeyboardButton.WithCallbackData("Доступные стажировки", "/internships") },
new[] { InlineKeyboardButton.WithCallbackData("FAQ", "/faq") },
new[] { InlineKeyboardButton.WithCallbackData("Правила приёма", "/rules") },
});
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : GoogleSheetsInterference.GetHelloMessage()
);
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "Мои команды:",
replyMarkup : inlineKeyboard
);
}
static async Task SendInlineKeyboard(Message message)
{
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
await Task.Delay(500);
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData("1.1", "1.2"),
},
new []
{
InlineKeyboardButton.WithUrl("Залететь на Хабр", "https://habr.com/ru/"),
}
});
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "choose your destiny",
replyMarkup : inlineKeyboard
);
}
/// <summary>
/// Вызывает команду
/// </summary>
/// <param name="message">принимает сообщение</param>
/// <param name="client">Ссылка на экземпляр бота</param>
public async void Execute(Message message, TelegramBotClient client)
{
var chatId = message.Chat.Id;
var messageId = message.MessageId;
var keyboard = new Telegram.Bot.Types.ReplyMarkups.InlineKeyboardMarkup(new[]
{
new [] // first row
{
InlineKeyboardButton.WithUrl("1.1", "www.google.com"),
InlineKeyboardButton.WithCallbackData("1.2", "callback1"),
},
new [] // second row
{
InlineKeyboardButton.WithCallbackData("2.1", "callback2"),
InlineKeyboardButton.WithCallbackData("2.2"),
}
});
await client.SendTextMessageAsync(chatId, "Жамкни!", replyMarkup : keyboard);
client.OnCallbackQuery += async(object sender, Telegram.Bot.Args.CallbackQueryEventArgs ev) =>
{
var CBQMessage = ev.CallbackQuery.Message;
if (ev.CallbackQuery.Data == "callback1")
{
await client.AnswerCallbackQueryAsync(ev.CallbackQuery.Id, "Ты выбрал " + ev.CallbackQuery.Data, true);
}
else
if (ev.CallbackQuery.Data == "callback2")
{
await client.SendTextMessageAsync(CBQMessage.Chat.Id, "тест", replyToMessageId : CBQMessage.MessageId);
await client.AnswerCallbackQueryAsync(ev.CallbackQuery.Id); // отсылаем пустое, чтобы убрать "часики" на кнопке
}
};
client.StartReceiving();
}
public static InlineKeyboardMarkup MainMenuForMainAdmin() => new InlineKeyboardMarkup(
new[]
{
new []
{
InlineKeyboardButton.WithCallbackData("Выбрать девушку"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Добавить новую девушку"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Удалить девушку из списка"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Показать статистику"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Оповестить всех 'Я в сети'")
}
});
static async Task HandleUpdateAsync(ITelegramBotClient botClient, Update update, CancellationToken cancellationToken)
{
if (update.Type == UpdateType.Message && update.Message != null && update.Message.Type == MessageType.Text)
{
long chatId = update.Message.Chat.Id;
string messageText = update.Message.Text;
if (messageText == "/start")
{
string menu = "/start - запуск\n/inline - меню\n/keyboard - сообщения\n/clearkeyboard - убрать кнопки";
await botClient.SendTextMessageAsync(chatId, menu, cancellationToken : cancellationToken);
}
else if (messageText == "/inline")
{
InlineKeyboardMarkup inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new[]
{
InlineKeyboardButton.WithUrl("VK", "https://vk.com/mishanya167"),
InlineKeyboardButton.WithUrl("LinkedIn", "https://www.linkedin.com/in/%D0%BC%D0%B8%D1%85%D0%B0%D0%B8%D0%BB-%D0%BA%D0%BE%D0%B2%D0%B0%D0%BB%D1%91%D0%B2-79637b164/")
},
new[]
{
InlineKeyboardButton.WithCallbackData("Дата и время", "DateTime"),
InlineKeyboardButton.WithCallbackData("Картинка", "Photo")
}
});
await botClient.SendTextMessageAsync(chatId, "Выберите пункт меню: ", replyMarkup : inlineKeyboard, cancellationToken : cancellationToken);
}
else if (messageText == "/keyboard")
{
ReplyKeyboardMarkup replayKeyBoard = new ReplyKeyboardMarkup(new[]
{
new[]
{
new KeyboardButton("Привет"),
new KeyboardButton("Как дела?")
},
new[]
{
KeyboardButton.WithRequestContact("Контакт"),
KeyboardButton.WithRequestLocation("Геолокация")
}
});
await botClient.SendTextMessageAsync(chatId, "Выберите сообщение.", replyMarkup : replayKeyBoard, cancellationToken : cancellationToken);
}
else if (messageText == "/clearkeyboard")
{
await botClient.SendTextMessageAsync(chatId, "Кнопки убраны.", replyMarkup : new ReplyKeyboardRemove(), cancellationToken : cancellationToken);
}
else
{
SessionsClient sessionsClient = await SessionsClient.CreateAsync();
SessionName sessionName = new SessionName("small-talk-srqi", Guid.NewGuid().ToString());
QueryInput queryInput = new QueryInput
{
Text = new TextInput
{
Text = messageText,
LanguageCode = "ru-Ru"
}
};
DetectIntentResponse response = await sessionsClient.DetectIntentAsync(sessionName, queryInput);
if (response.QueryResult.FulfillmentMessages.Count > 0)
{
await botClient.SendTextMessageAsync(chatId, response.QueryResult.FulfillmentText, cancellationToken : cancellationToken);
}
else
{
await botClient.SendTextMessageAsync(chatId, "Прости, я тебя не понимаю.", cancellationToken : cancellationToken);
}
}
}
if (update.Type == UpdateType.CallbackQuery && update.CallbackQuery.Message != null)
{
string data = update.CallbackQuery.Data;
if (data == "DateTime")
{
await botClient.AnswerCallbackQueryAsync(update.CallbackQuery.Id, DateTime.Now.ToString(), cancellationToken : cancellationToken);
}
if (data == "Photo")
{
await botClient.SendPhotoAsync(update.CallbackQuery.Message.Chat.Id, "https://big-rostov.ru/wp-content/uploads/2021/04/i-7-1.jpg", cancellationToken : cancellationToken);
}
}
}
private static async void BotOnMessageReceived(object sender, MessageEventArgs messageEventArgs)
{
var message = messageEventArgs.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
switch (message.Text.Split(' ').First())
{
// send inline keyboard
case "/inline":
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
await Task.Delay(500); // simulate longer running task
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new [] // first row
{
InlineKeyboardButton.WithCallbackData("First"),
InlineKeyboardButton.WithCallbackData("Second"),
},
new [] // second row
{
InlineKeyboardButton.WithCallbackData("First"),
InlineKeyboardButton.WithCallbackData("Second"),
}
});
await Bot.SendTextMessageAsync(
message.Chat.Id,
"Choose",
replyMarkup : inlineKeyboard);
break;
// send custom keyboard
case "/keyboard":
ReplyKeyboardMarkup ReplyKeyboard = new[]
{
new[] { "First", "Second" },
new[] { "First", "Second" },
};
await Bot.SendTextMessageAsync(
message.Chat.Id,
"Choose",
replyMarkup : ReplyKeyboard);
break;
// request location or contact
case "/request":
var RequestReplyKeyboard = new ReplyKeyboardMarkup(new[]
{
KeyboardButton.WithRequestLocation("Location"),
KeyboardButton.WithRequestContact("Contact"),
});
await Bot.SendTextMessageAsync(
message.Chat.Id,
"Who or Where are you?",
replyMarkup : RequestReplyKeyboard);
break;
default:
const string usage = @"
Usage:
/inline - send inline keyboard
/keyboard - send custom keyboard
/request - request location or contact
/subscribe - add to db datas";
await Bot.SendTextMessageAsync(
message.Chat.Id,
usage,
replyMarkup : new ReplyKeyboardRemove());
break;
}
}
private static async void BotOnCallbackQueryReceived(object sender, CallbackQueryEventArgs e)
{
var message = e.CallbackQuery.Message;
string data = e.CallbackQuery.Data;
switch (data)
{
case "Абитуриент":
var keyboard_first = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData("Как поступить в SU?", "first")
},
new []
{
InlineKeyboardButton.WithCallbackData("Список документов для поступления", "second")
},
new []
{
InlineKeyboardButton.WithCallbackData("В какое время можно подать документы? Можно ли сделать это в субботу или воскресенье?", "third")
},
new []
{
InlineKeyboardButton.WithCallbackData("Могу ли я подать документы лично, если мне меньше 18 лет? Или обязательно присутствие родителей?", "four")
},
new []
{
InlineKeyboardButton.WithCallbackData("Контакты приемной комиссии?", "five")
},
new []
{
InlineKeyboardButton.WithCallbackData("График работы приемной комиссии?", "six")
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, e.CallbackQuery.Message.Text, replyMarkup : keyboard_first);
Bot.OnCallbackQuery += async(object sc, CallbackQueryEventArgs ev) =>
{
var message = ev.CallbackQuery.Message;
switch (ev.CallbackQuery.Data)
{
case "first":
await Bot.SendTextMessageAsync(message.Chat.Id, "Зарегистрироваться в онлайн режиме по адресу kb.satbayev.university");
break;
case "second":
await Bot.SendTextMessageAsync(message.Chat.Id, "1. Заявление на поступление 2.Аттестат о среднем общем или диплом о начальном профессиональном или среднем профессиональном образовании(оригинал) 3.Фото формата 3х4 – 6шт 4.Медицинская справка по форме 086 - У 5.Прививочная карта по форме 063 6.Снимок флюорографии 7.Документ, подтверждающий преимущественное право 8.Сертификат ЕНТ или комплексного тестирования 9.Свидетельство о присуждении гранта(при его наличии) 10.Копия удостоверении личности 11.Приписное свидетельство ");
break;
case "third":
await Bot.SendTextMessageAsync(message.Chat.Id, "Подать документы можно в рабочие часы Приёмной комиссии. Они будут объявлены ближе к старту приёмной кампании.");
break;
case "four":
await Bot.SendTextMessageAsync(message.Chat.Id, "Вы можете подать документы и самостоятельно, только не забудьте взять с собой паспорт. Но помните: если вы поступаете на место на коммерческой основе, то заключить договор, будучи несовершеннолетним, вы самостоятельно не сможете — необходимо присутствие родителя. Кроме того, если вам меньше 18, вам обязательно нужно будет принести форму согласия на обработку ваших персональных данных, подписанную родителем или опекуном (без неё документы не примут!).");
break;
case "five":
await Bot.SendTextMessageAsync(message.Chat.Id, "Республика Казахстан, г. Алматы, ул. Сатпаева 22а, Главный учебный корпус (ГУК). Вход со стороны ул. Байтурсынова. +7 (727) 292 7301 +7 (727) 292 7779 +7 (727) 320 4112 [email protected]");
break;
case "six":
await Bot.SendTextMessageAsync(message.Chat.Id, "График работы: пн - пт, с 8:30 до 17:30 сб, с 9:00 до 17:00 ");
break;
}
};
break;
case "Бакалавриат":
var keyboard_second = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData("Есть ли общежитие? Какие критерии и требования для получения комнаты в общежитии SU?", "first"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Имеется ли в университете военная кафедра? Есть ли необходимость доплаты за военную кафедру?", "second"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Что такое кредитная технология обучения?", "third"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Какие студентческие сообщества есть в университете?", "forth"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Как вступить в один из таких сообществ?", "fifth"),
},
new []
{
InlineKeyboardButton.WithCallbackData("При каких обстоятельствах студент лишается гранта", "sixth"),
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, e.CallbackQuery.Message.Text, replyMarkup : keyboard_second);
Bot.OnCallbackQuery += async(object sc, CallbackQueryEventArgs ev) =>
{
var message = ev.CallbackQuery.Message;
switch (ev.CallbackQuery.Data)
{
case "firth":
await Bot.SendTextMessageAsync(message.Chat.Id, "Да, в SU есть общежитие. Для того, чтобы получить место в общежитии необходимо написать заявление, все заявления в конце августа рассматривает комиссия. В первую очередь места предоставляются иногородним первокурсникам для благополучной адаптации и привыканию к новому месту жительства в первый год обучения. Вторым не маловажным условием для получения места в общежитии является материальное положение студента (при наличии подтверждающих документов).");
break;
case "second":
await Bot.SendTextMessageAsync(message.Chat.Id, "В университете имеется военная кафедра, зачисление юношей на военную подготовку производится после 1 курса на конкурсной основе. Для обучения на военной кафедре выделяется государственный заказ.");
break;
case "third":
await Bot.SendTextMessageAsync(message.Chat.Id, "Кредитная технология обучения – способ организации учебного процесса, при котором обучающиеся в определенных границах имеют возможность индивидуально планировать последовательность образовательной траектории.");
break;
case "forth":
await Bot.SendTextMessageAsync(message.Chat.Id, "«Жас Отан», «Лига Волонтеров», Дебатные клубы, Enactus, Society of Automotive Engineers, American Association of Petroleum Geologists, Society of Petroleum Engineers");
break;
case "fifth":
await Bot.SendTextMessageAsync(message.Chat.Id, "Ежегодно в сентябре проводится «Ярмарка студенческих сообществ», во время которой каждый желающий может открыть и презентовать свое сообщество или вступить в то сообщество, которое ему понравилось.");
break;
case "sixth":
await Bot.SendTextMessageAsync(message.Chat.Id, "Обучающиеся, обладатели образовательных грантов, оставленные на повторный курс обучения, лишаются образовательного гранта и продолжают свое дальнейшее обучение на платной основе. Если годовой gpa будет меньше 1,6 то студент теряет государственный образовательный грант. Если студент в итоге за дисциплину получает удовлетворительную оценку, то студент теряет стипендию.");
break;
}
};
break;
case "Преподаватель":
var keyboard_third = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithUrl("Академический календарь", "https://drive.google.com/uc?export=download&id=10Z7T0DhO08kwQLA76YI1aYqkP8ZVxBSK"),
},
new []
{
InlineKeyboardButton.WithUrl("Скачать форму отчета", "https://drive.google.com/uc?export=download&id=1nEEsECD2od_zsFZlgLMWKUnB3f3VOK0T"),
},
new []
{
InlineKeyboardButton.WithCallbackData("", "third"),
},
new []
{
InlineKeyboardButton.WithCallbackData("", "forth"),
},
new []
{
InlineKeyboardButton.WithCallbackData("", "fifth"),
},
new []
{
InlineKeyboardButton.WithCallbackData("", "sixth"),
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, e.CallbackQuery.Message.Text, replyMarkup : keyboard_third);
break;
case "МК":
var keyboard_fourth = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData("Главный учебный корпус", "first")
},
new []
{
InlineKeyboardButton.WithCallbackData("Горно-металлургический институт имени О. Байконурова", "second")
},
new []
{
InlineKeyboardButton.WithCallbackData("Медицинский пункт", "third")
},
new []
{
InlineKeyboardButton.WithCallbackData("Нефтянной корпус", "four")
},
new []
{
InlineKeyboardButton.WithCallbackData("Военная кафедра", "five")
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, e.CallbackQuery.Message.Text, replyMarkup : keyboard_fourth);
Bot.OnCallbackQuery += async(object sc, CallbackQueryEventArgs ev) =>
{
var message = e.CallbackQuery.Message;
switch (ev.CallbackQuery.Data)
{
case "first":
float Latitude1 = 43.236422f;
float Longitude1 = 76.929755f;
await Bot.SendLocationAsync(message.Chat.Id, Latitude1, Longitude1);
break;
case "second":
float Latitude2 = 43.236520f;
float Longitude2 = 76.931572f;
await Bot.SendLocationAsync(message.Chat.Id, Latitude2, Longitude2);
break;
case "third":
float Latitude3 = 43.237319f;
float Longitude3 = 76.934405f;
await Bot.SendLocationAsync(message.Chat.Id, Latitude3, Longitude3);
break;
case "four":
float Latitude4 = 43.237093f;
float Longitude4 = 76.931374f;
await Bot.SendLocationAsync(message.Chat.Id, Latitude4, Longitude4);
break;
case "five":
float Latitude5 = 43.231572f;
float Longitude5 = 76.934406f;
await Bot.SendLocationAsync(message.Chat.Id, Latitude5, Longitude5);
break;
}
};
break;
}
/*if (buttonText == "Картинка")
* {
* await Bot.SendTextMessageAsync(e.CallbackQuery.From.Id, "https://cdn.lifehacker.ru/wp-content/uploads/2019/06/telegram_1560950950.jpg");
* }
* else if (buttonText == "Документ")
* {
* // await Bot.SendTextMessageAsync(e.CallbackQuery.From.Id, "https://drive.google.com/uc?export=download&id=0B3Rr6xomyKzhc09hSW4xOGt2SmlHYl95ZWpRYnVOZkhwa0NJ");
* }
*
* await Bot.AnswerCallbackQueryAsync(e.CallbackQuery.Id, $"Вы нажали кнопку {buttonText}");*/
}
private static async void BotOnMessageReceived(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
var message = e.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
string name = $"{message.From.FirstName} {message.From.LastName}";
Console.WriteLine($"{name} sent message: {message.Text}");
switch (message.Text)
{
case "/start":
{
string text =
@"List of commands:
/start - launch bot;
/inline - show menu;
/keyboard - show keyboard;";
await Bot.SendTextMessageAsync(message.From.Id, text);
break;
}
case "/keyboard":
{
var replyKeyboard = new ReplyKeyboardMarkup(new[]
{
new[]
{
new KeyboardButton("Привет!"),
new KeyboardButton("Как дела?")
},
new[]
{
new KeyboardButton("Контакт")
{
RequestContact = true
},
new KeyboardButton("Геолокация")
{
RequestLocation = true
}
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, "Message",
replyMarkup : replyKeyboard);
break;
}
case "/inline":
{
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new[]
{
InlineKeyboardButton.WithUrl("VK", "https://vk.com/id11833696"),
InlineKeyboardButton.WithUrl("Telegram", "https://t.me/trakhimovichilya")
},
new[]
{
InlineKeyboardButton.WithCallbackData("картинка"),
InlineKeyboardButton.WithCallbackData("видео")
}
});
await Bot.SendTextMessageAsync(message.From.Id, "Select menu",
replyMarkup : inlineKeyboard);
break;
}
default:
{
var response = apiAi.TextRequest(message.Text);
string answer = response.Result.Fulfillment.Speech;
if (answer == "")
{
answer = "Прости, я тебя не понял. Я тупой еще :(.";
}
await Bot.SendTextMessageAsync(message.From.Id, answer);
break;
}
}
}
private static async void BotOnMessageReceived(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
var message = e.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
string name = $"{message.From.FirstName} {message.From.LastName}";
Console.WriteLine($"{name} отправил(-а) сообщение: '{message.Text}'");
switch (message.Text)
{
case "/start":
string text =
@" Список команд:
/start - запустить бота
/hello - поприветствовать
/callback - вывод меню
/keyboard - клавиатура";
await Bot.SendTextMessageAsync(message.From.Id, text);
break;
case "/callback": // для отправки меню
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new [] // первая строка
{
InlineKeyboardButton.WithUrl("Github", "Github.com"),
InlineKeyboardButton.WithUrl("Instagram", "instagram.com"),
InlineKeyboardButton.WithUrl("Telegram", "https://t.me/")
},
new [] // вторая строка
{
InlineKeyboardButton.WithCallbackData("Point 1"),
InlineKeyboardButton.WithCallbackData("Point 2"),
}
});
await Bot.SendTextMessageAsync(message.From.Id, "Выберите пункт меню", replyMarkup : inlineKeyboard);
break;
case "/keyboard": // клавиатура
var replyKeyboard = new ReplyKeyboardMarkup(new []
{
new []
{
new KeyboardButton("Профиль"),
new KeyboardButton("О боте")
},
new []
{
new KeyboardButton("Контакт"),
new KeyboardButton("Геолокация")
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, "Сообщение", replyMarkup : replyKeyboard);
break;
case "/hello":
string text1 =
@"Приветствую!";
await Bot.SendTextMessageAsync(message.From.Id, text1);
break;
default:
var response = apiAi.TextRequest(message.Text); // ответ юзеру
string answer = response.Result.Fulfillment.Speech; // получаем ответ от диалогфлоу
if (answer == "")
{
answer = "Прости, моя твоя не понимать :( ";
}
await Bot.SendTextMessageAsync(message.From.Id, answer);
break;
}
}
private async Task BotOnMessageReceived(Message message)
{
Console.WriteLine($"Receive message type: {message.Type}");
if (message.Type != MessageType.Text)
{
return;
}
var action = (message.Text.Split(' ').First()) switch
{
"/inline" => SendInlineKeyboard(message),
"/keyboard" => SendReplyKeyboard(message),
"/photo" => SendFile(message),
"/request" => RequestContactAndLocation(message),
"/help" => Usage(message),
_ => Nope(message)
};
await action;
// Send inline keyboard
// You can process responses in BotOnCallbackQueryReceived handler
async Task SendInlineKeyboard(Message message)
{
await _bot.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
// Simulate longer running task
await Task.Delay(500);
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
// first row
new []
{
InlineKeyboardButton.WithCallbackData("1.1", "11"),
InlineKeyboardButton.WithCallbackData("1.2", "12"),
},
// second row
new []
{
InlineKeyboardButton.WithCallbackData("2.1", "21"),
InlineKeyboardButton.WithCallbackData("2.2", "22"),
}
});
await _bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "Choose",
replyMarkup : inlineKeyboard
);
}
async Task SendReplyKeyboard(Message message)
{
var replyKeyboardMarkup = new ReplyKeyboardMarkup(
new KeyboardButton[][]
{
new KeyboardButton[] { "1.1", "1.2" },
new KeyboardButton[] { "2.1", "2.2" },
},
resizeKeyboard: true
);
await _bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "Choose",
replyMarkup : replyKeyboardMarkup
);
}
async Task SendFile(Message message)
{
await _bot.SendChatActionAsync(message.Chat.Id, ChatAction.UploadPhoto);
const string filePath = @"Files/tux.png";
using var fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
var fileName = filePath.Split(Path.DirectorySeparatorChar).Last();
await _bot.SendPhotoAsync(
chatId : message.Chat.Id,
photo : new InputOnlineFile(fileStream, fileName),
caption : "Nice Picture"
);
}
async Task RequestContactAndLocation(Message message)
{
var RequestReplyKeyboard = new ReplyKeyboardMarkup(new[]
{
KeyboardButton.WithRequestLocation("Location"),
KeyboardButton.WithRequestContact("Contact"),
});
await _bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "Who or Where are you?",
replyMarkup : RequestReplyKeyboard
);
}
async Task Usage(Message message)
{
const string usage = "Usage:\n" +
"/inline - send inline keyboard\n" +
"/keyboard - send custom keyboard\n" +
"/photo - send a photo\n" +
"/request - request location or contact";
await _bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : usage,
replyMarkup : new ReplyKeyboardRemove()
);
}
Task Nope(Message message)
{
return(Task.CompletedTask);
}
}
// async OnMessage event task for the bot
// it has to be async so the bot can be always listening
private async static void BotClient_OnMessage(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
// Normal text message. Checks wether the message does have text.
// in case it does, the bot answers.
#region Text Message
if (e.Message.Text != null)
{
Console.WriteLine($"Received text message in chat {e.Message.Chat.Id}.");
// the bot sends asynchronously a message to the chat
await botClient.SendTextMessageAsync(
chatId : e.Message.Chat.Id,
text : "You said:\n" + e.Message.Text
);
}
#endregion
// Normal text message, with all the properties
// a text message can have.
#region Text message with properties
Message textMessage = await botClient.SendTextMessageAsync(
chatId : e.Message.Chat, // or a chat id: 123456789
text : "Trying *all the parameters* of `sendMessage` method",
parseMode : ParseMode.Markdown,
disableNotification : true,
replyToMessageId : e.Message.MessageId,
replyMarkup : new InlineKeyboardMarkup(InlineKeyboardButton.WithUrl(
"Check sendMessage method",
"https://core.telegram.org/bots/api#sendmessage"
))
);
#endregion
// Almost all of the methods for sending messages return you
// the message you just sent.
#region Messages return you the message you sent (as an object)
Console.WriteLine(
$"{textMessage.From.FirstName} sent message {textMessage.MessageId} " +
$"to chat {textMessage.Chat.Id} at {textMessage.Date.ToLocalTime()}. " + // if you don't use ToLocalTime(), the bot will show the UTC time.
$"It is a reply to message {textMessage.ReplyToMessage.MessageId} " +
$"and has {textMessage.Entities.Length} message entities."
);
#endregion
// Photo message. It gets the image from a URL on the internet.
// All images can have captions. You can use HTML or Markdown on them.
#region Photo Message
Message photoMessage = await botClient.SendPhotoAsync(
chatId : e.Message.Chat,
photo : "https://github.com/TelegramBots/book/raw/master/src/docs/photo-ara.jpg",
caption : "<b>Ara bird</b>. <i>Source</i>: <a href=\"https://pixabay.com\">Pixabay</a>",
parseMode : ParseMode.Html
);
#endregion
// Sticker message. Sticker files should be in WebP format.
// Sends two messages. The first one gets the sticker by passing HTTP URL
// to WebP sticker file, and the second by reusing the file_id of the
// first sticker (kinda like a cache?)
#region Sticker Messages
Message stickerMessage1 = await botClient.SendStickerAsync(
chatId : e.Message.Chat,
sticker : "https://github.com/TelegramBots/book/raw/master/src/docs/sticker-fred.webp"
);
Message stickerMessage2 = await botClient.SendStickerAsync(
chatId : e.Message.Chat,
sticker : stickerMessage1.Sticker.FileId
);
#endregion
// Audio message. Opens it in Media Player. MP3 Format.
// Telegram can read metadata from the MP3 file (that's why
// there are commented properties; the bot gets the same
// properties, but from the file metadata!)
#region Audio Message
Message audioMessage = await botClient.SendAudioAsync(
e.Message.Chat,
"https://github.com/TelegramBots/book/raw/master/src/docs/audio-guitar.mp3"
/*,
* performer: "Joel Thomas Hunger",
* title: "Fun Guitar and Ukulele",
* duration: 91 // in seconds
*/
);
#endregion
// Voice message. Not opened in Media Player (played directly
// on the chat). OGG Format.
// In this case, the OGG file is on our disk!
#region Voice Message
Message voiceMessage;
using (var stream = System.IO.File.OpenRead("C:/Users/Biel/source/repos/TelegramBot/voice-nfl_commentary.ogg"))
{
voiceMessage = await botClient.SendVoiceAsync(
chatId : e.Message.Chat,
voice : stream,
duration : 36
);
}
#endregion
// You can send MP4 files as a regular video or as a video note.
// Other video formats must be sent as a file.
// Video message. They can have caption, reply, and reply markup
// (like other multimedia messages)
// You can optionally specify the duration and the resolution
// of the video. In this case the video is streamed,
// meaning the user can partly watch the video on stream, without
// having to download it completely.
#region Video Message
Message videoMessage = await botClient.SendVideoAsync(
chatId : e.Message.Chat,
video : "https://raw.githubusercontent.com/TelegramBots/book/master/src/docs/video-countdown.mp4",
thumb : "https://raw.githubusercontent.com/TelegramBots/book/master/src/2/docs/thumb-clock.jpg",
supportsStreaming : true
);
#endregion
// Video note message. They are shown in circles to the user.
// They are usually short (1 minute or less).
// You can send a video note only by the video file or
// reusing the file_id of another video note.
// (sending it by its HTTP URL is not supported currently)
#region Video Note Message
Message videoNoteMessage;
using (var stream = System.IO.File.OpenRead("C:/Users/step/Source/Repos/TelegramBotExamples/video-waves.mp4"))
{
videoNoteMessage = await botClient.SendVideoNoteAsync(
chatId : e.Message.Chat,
videoNote : stream,
duration : 47,
length : 360 // value of width/height
);
}
#endregion
// Poll message. They can be sent only to groups and channels.
// You can optionally send a keyboard with a poll,
// both inline and a regular one.
#region Poll Message
Message pollMessage = await botClient.SendPollAsync(
chatId : "@group_or_channel_username",
question : "Did you ever hear the tragedy of Darth Plagueis The Wise?",
options : new []
{
"Yes for the hundredth time!",
"No, who's that?"
}
);
#endregion
// To stop the poll, you need to know original chat and message ids
// (you get them from the Poll object you get on SendPollAsync, the pollMessage)
#region Closing a Poll
Poll poll = await botClient.StopPollAsync(
chatId : pollMessage.Chat.Id,
messageId : pollMessage.MessageId
);
#endregion
// Filtering messages for commands
if (e.Message.Text == "/sayhello")
{
Message sayHello = await botClient.SendTextMessageAsync
(
chatId : e.Message.Chat.Id,
text : "Hello! Glad to see you!"
);
}
if (e.Message.Text == "/saygoodbye")
{
Message sayHello = await botClient.SendTextMessageAsync
(
chatId : e.Message.Chat.Id,
text : "Bye! Have a nice day!"
);
}
}
private static async void BotOnMessageReceived(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
var message = e.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
string name = $"{message.From.FirstName} {message.From.LastName}";
Console.WriteLine($"{name} отправил сообщение: {message.Text}");
switch (message.Text)
{
case "/start":
string text =
@"Список команд:
/start - запуск бота
/menu - вывод меню
/keyboard - ввод с клавиатуры";
await Bot.SendTextMessageAsync(message.From.Id, text);
break;
case "/menu":
var inlineKeyboard = new InlineKeyboardMarkup(new[] {
new[]
{
InlineKeyboardButton.WithUrl("VK ILUSHA", "https://vk.com/special0ps"),
InlineKeyboardButton.WithUrl("VK ANDRUSHA", "https://vk.com/id231468284")
},
new[]
{
InlineKeyboardButton.WithCallbackData("Картинка"),
InlineKeyboardButton.WithCallbackData("Видео")
}
});
await Bot.SendTextMessageAsync(message.From.Id, "Выберите пункт меню", replyMarkup : inlineKeyboard);
break;
case "/keyboard":
var replyKeyboard = new ReplyKeyboardMarkup(new[]
{
new[]
{
new KeyboardButton("Привет"),
new KeyboardButton("Как дела?")
},
new[]
{
new KeyboardButton("Контакт")
{
RequestContact = true
},
new KeyboardButton("Геолокация")
{
RequestLocation = true
}
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, "Сообщение", replyMarkup : replyKeyboard);
break;
default:
var response = apiAi.TextRequest(message.Text);
string answer = response.Result.Fulfillment.Speech;
if (answer == "")
{
answer = "Я тебя не понимаю:(";
}
await Bot.SendTextMessageAsync(message.From.Id, answer);
break;
}
}
private static async void BotOnMessageReceived(object sender, MessageEventArgs messageEventArgs)
{
var message = messageEventArgs.Message;
if (message == null || message.Type != MessageType.TextMessage)
{
mainInfo(message.Chat.Id);
}
else if (message.Text.StartsWith("/getacronym"))
{
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
string acronym = String.Empty;
string[] delimiter = { " " };
if (message.Text.Contains(delimiter[0]))
{
acronym = message.Text.Split(delimiter, StringSplitOptions.RemoveEmptyEntries)[1].Trim();
var url = "http://10.10.11.35:3000/earthtionary/acronym/" + acronym;
var json = new WebClient().DownloadString(url);
List <Acronym> deserializedProduct = JsonConvert.DeserializeObject <List <Acronym> >(json);
List <string> allWords = new List <string>();
deserializedProduct.ForEach(x =>
{
x.word.ToList().ForEach(y =>
{
allWords.Add(y);
});
});
string[] words = allWords.ToArray();
InlineKeyboardButton[] buttons = new InlineKeyboardButton[words.Length];
if (words.Length > 0)
{
int i = 0;
words.ToList().ForEach(x =>
{
buttons[i] = new InlineKeyboardButton(x);
i++;
});
var keyboard = new InlineKeyboardMarkup(buttons);
await Task.Delay(500);
await Bot.SendTextMessageAsync(message.Chat.Id, "Choose",
replyMarkup : keyboard);
}
else
{
await Bot.SendTextMessageAsync(message.Chat.Id, "No result was founded");
}
}
else
{
await Bot.SendTextMessageAsync(message.Chat.Id, "You have to send an acronym, if you want to find a definition");
}
}
else if (message.Text.StartsWith("/getdefinition"))
{
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
string acronym = String.Empty;
string[] delimiter = { " " };
if (message.Text.Contains(delimiter[0]))
{
string[] def = message.Text.Split(delimiter, StringSplitOptions.RemoveEmptyEntries);
if (def.Length > 1)
{
string word = String.Empty;
int i = 0;
def.ToList().ForEach(x =>
{
if (i != 0)
{
if (String.IsNullOrEmpty(word))
{
word += x;
}
else
{
word += " " + x;
}
}
i++;
});
var url = "http://10.10.11.35:3000/earthtionary/word/" + word.Replace(" ", "%20");
var json = new WebClient().DownloadString(url);
List <Acronym> deserializedProduct = JsonConvert.DeserializeObject <List <Acronym> >(json);
int j = 1;
string definition = "Definition of " + word + ":\r\n\r\n";
deserializedProduct.ForEach(x =>
{
if (!String.IsNullOrEmpty(x.text))
{
definition += "Definition " + j + ": " + x.text + "\r\n";
j++;
}
});
if (j > 1)
{
await Bot.SendTextMessageAsync(message.Chat.Id, definition);
}
else
{
await Bot.SendTextMessageAsync(message.Chat.Id, "No result was founded");
}
}
}
else
{
await Bot.SendTextMessageAsync(message.Chat.Id, "You have to send a word, if you want to find a definition");
}
}
else if (message.Text.StartsWith("/"))
{
return;
}
else
{
mainInfo(message.Chat.Id);
}
}
private static async void BotOnMessageReceived(object sender, MessageEventArgs messageEventArgs)
{
var message = messageEventArgs.Message;
if (message.Type == MessageType.Photo)
{
var test = Bot.GetFileAsync(message.Photo[message.Photo.Count() - 1].FileId);
Console.Write(test.Result);
var download_url = @"https://api.telegram.org/file/bot<token>/" + test.Result.FilePath;
}
if (message == null || message.Type != MessageType.Text)
{
return;
}
if (message.Text.Equals("1") || message.Text.Equals("2") || message.Text.Equals("3") || message.Text.Equals("4") || message.Text.Equals("5"))
{
await ListarHotelesAsync(message.Chat.Id, "Clasificación", message.Text);
return;
}
if (message.Text.Equals("San José") || message.Text.Equals("Cartago") || message.Text.Equals("Alajuela") || message.Text.Equals("Heredia") ||
message.Text.Equals("Limón") || message.Text.Equals("Puntarenas") || message.Text.Equals("Guanacaste"))
{
await ListarHotelesAsync(message.Chat.Id, "Provincia", message.Text);
return;
}
if (message.ReplyToMessage != null && message.ReplyToMessage.Text.Equals("Para listar sus reservas, por favor ingrese su número de cédula"))
{
await ListarReservasAsync(message.Chat.Id, message.Text);
}
switch (message.Text.Split(' ').First())
{
case "/reservas":
await Bot.SendTextMessageAsync(
message.Chat.Id,
"Mis reservas");
break;
case "/ubicacion":
await Bot.SendTextMessageAsync(
message.Chat.Id,
"Ubicación");
break;
case "Todos":
await ListarHotelesAsync(message.Chat.Id, "Todos", message.Text);
break;
case "Estrellas":
List <string> estrellasHotel = new List <string>
{
"5", "4", "3", "2", "1"
};
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "¿Cantidad de estrellas?",
replyMarkup : GetReplyKeyboard(estrellasHotel));
break;
case "Provincia":
ReplyKeyboardMarkup ubicacionHotel = new[]
{
new[] { "San José", "Cartago" },
new[] { "Alajuela", "Heredia" },
new[] { "Limón", "Puntarenas" },
new[] { "Guanacaste" }
};
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "Seleccione una provincia",
replyMarkup : ubicacionHotel);
break;
case "/hoteles":
List <string> filtroHoteles = new List <string>
{
"Todos",
"Estrellas",
"Ubicación",
"Calificación"
};
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : "¿Cómo desea listar los hoteles?",
replyMarkup : GetReplyKeyboard(filtroHoteles));
break;
default:
await Bot.SendChatActionAsync(message.Chat.Id, ChatAction.Typing);
await Task.Delay(5);
var keyboardEjemplo1 = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData(
text: "Hoteles",
callbackData: "hoteles"),
InlineKeyboardButton.WithCallbackData(
text: "Reservas",
callbackData: "reservas"),
}
});
await Bot.SendTextMessageAsync(
message.Chat.Id,
"Hola, " + message.Chat.FirstName + " ¿En qué podemos ayudarle?",
replyMarkup : keyboardEjemplo1);
break;
}
}
static async void LoadChoices(string data, long chat_id, string start_choice) // Ситуация с выборами.
{
var description = dataBase.recive_text(data, start_choice) + "\n";
var childs = dataBase.get_childs(data, start_choice);
if (childs[0] == "0" || childs[0] == "-1")
{
if (childs[0] == "-1")
{
usersDataBase.situation_done(chat_id, int.Parse(data));
var backButton = new InlineKeyboardButton()
{
Text = "Успешно, назад", CallbackData = "/start"
};
var local_markup = new InlineKeyboardMarkup(backButton);
await botClient.SendTextMessageAsync(
chatId : chat_id,
text : description,
replyMarkup : local_markup
);
}
else
{
var backButton = new InlineKeyboardButton()
{
Text = "Назад", CallbackData = "/start"
};
var local_markup = new InlineKeyboardMarkup(backButton);
await botClient.SendTextMessageAsync(
chatId : chat_id,
text : description,
replyMarkup : local_markup
);
}
return;
}
List <InlineKeyboardButton> buttons = new List <InlineKeyboardButton>();
for (var i = 0; i < childs.Length; i++)
{
description += $"<b>\n{i}. " + dataBase.recive_text(data, childs[i]) + "</b>";
buttons.Add(new InlineKeyboardButton()
{
Text = i.ToString(),
CallbackData = "Choice." + dataBase.get_childs(data, childs[i])[0] + "." + data // Всегда отсылают к одному варианту.
});
}
var markup = new InlineKeyboardMarkup(buttons);
await botClient.SendTextMessageAsync(
chatId : chat_id,
text : description,
replyMarkup : markup,
parseMode : ParseMode.Html
);
}
public async Task SendChancellorChooseLawAsync(string txt)
{
var replyKeyboardMarkup = new InlineKeyboardMarkup(DraftedLaws.Select((law, index) => InlineKeyboardButton.WithCallbackData(
law.ToString(),
$"{ChatId}:ChooseLaw:{index}"
)));
await Bot.Instance.SendTextMessageAsync(
chatId : Board.Chancellor.User.Id,
text : txt,
replyMarkup : replyKeyboardMarkup);
}
private static async void BotOnMessageReceived(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
var message = e.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
string user_name = $"{message.From.FirstName} {message.From.LastName} {message.From.Id} @{message.From.Username}";
Console.WriteLine($"{user_name} отправил: '{message.Text}'");
/*
* if (check_method == true)
* {
* check_dilog(message.From.Id, message.From.FirstName, "@" + message.From.Username);
* }
*/
string Users_message = "Выберите, что хотите сделать или нажмите \"помощь\", для прочтение подсказки";
switch (message.Text)
{
case "/start":
check_method = true;
if (check_method == true)
{
check_dilog(message.From.Id, message.From.FirstName, "@" + message.From.Username);
if (users_autorization == true)
{
number_button_info = "Добавить данные";
}
else if (users_autorization == false)
{
number_button_info = "Изменить данные";
}
}
var inlinekeyboard = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData(number_button_info),
InlineKeyboardButton.WithCallbackData("Найти людей"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Помощь")
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, Users_message, replyMarkup : inlinekeyboard);
break;
case "/help":
string info_message = "Добрый день! " +
"\n Данный бот может помочь тебе найти человека, " +
"\n с которым тебе было бы интересно общаться. " +
"\n Если у тебя совпадут более, чем 2 хобби, " +
"\n то вы сможете познакомиться!!!" +
"\n\n Скорее нажимай на \"Назад\", затем на \"Найти людей\" и закомься)";
var back_button = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData("Назад")
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, info_message, replyMarkup : back_button);
break;
case "/clear":
await Bot.SendTextMessageAsync(message.Chat.Id, "Подождите немного...");
for (int i = e.Message.MessageId - 20; i < e.Message.MessageId + 20; i++)
{
try
{
await Bot.DeleteMessageAsync(e.Message.Chat.Id, i);
}
catch
{ }
}
if (users_autorization == true)
{
number_button_info = "Добавить данные";
}
else if (users_autorization == false)
{
number_button_info = "Изменить данные";
}
var inlinekeyboard_after_clear = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData(number_button_info),
InlineKeyboardButton.WithCallbackData("Найти людей"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Помощь")
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, Users_message, replyMarkup : inlinekeyboard_after_clear);
break;
default:
if (Users_answer == "Добавить данные")
{
string error = data_base(false, message.Text, message.From.Id);
for (int i = message_id - 20; i < message_id + 20; i++)
{
//{
// try
// {
// await Bot.DeleteMessageAsync(e.Message.Chat.Id, i);
// }
// catch
// { }
//}
if (users_autorization == true)
{
number_button_info = "Добавить данные";
}
else if (users_autorization == false)
{
number_button_info = "Изменить данные";
}
}
var inlinekeyboard_after_add = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData(number_button_info),
InlineKeyboardButton.WithCallbackData("Найти людей"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Помощь")
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, Users_message, replyMarkup : inlinekeyboard_after_add);
if (error != "")
{
await Bot.SendTextMessageAsync(message.Chat.Id, error);
}
}
else if (Users_answer == "Изменить данные")
{
string error = data_base(true, message.Text, message.From.Id);
for (int i = message_id - 2; i < message_id + 10; i++)
{
try
{
await Bot.DeleteMessageAsync(e.Message.Chat.Id, i);
}
catch
{
}
}
if (users_autorization == true)
{
number_button_info = "Добавить данные";
}
else if (users_autorization == false)
{
number_button_info = "Изменить данные";
}
var inlinekeyboard_after_upgrade = new InlineKeyboardMarkup(new[]
{
new []
{
InlineKeyboardButton.WithCallbackData(number_button_info),
InlineKeyboardButton.WithCallbackData("Найти людей"),
},
new []
{
InlineKeyboardButton.WithCallbackData("Помощь")
}
});
await Bot.SendTextMessageAsync(message.Chat.Id, Users_message, replyMarkup : inlinekeyboard_after_upgrade);
if (error != "")
{
await Bot.SendTextMessageAsync(message.Chat.Id, error);
}
}
else if (Users_answer == "Найти людей")
{
await Bot.DeleteMessageAsync(e.Message.Chat.Id, message_id + 1); //
await Bot.DeleteMessageAsync(e.Message.Chat.Id, e.Message.MessageId); // Удаляет последнее сообщение
}
else
{
//for (int i = e.Message.MessageId - 2; i <= e.Message.MessageId + 10; i++)
//{
// try
// {
// await Bot.DeleteMessageAsync(e.Message.Chat.Id, i);
// }
// catch
// {
// if (i != e.Message.MessageId - 2)
// break;
// }
//
//await Bot.SendTextMessageAsync(message.Chat.Id, Users_message, replyMarkup: inlinekeyboard);
//await Bot.SendTextMessageAsync(message.From.Id, "Я вас не понимаю!");
}
Users_answer = "";
break;
}
}
private async void Bot_OnCallbackQuery(object sender, Telegram.Bot.Args.CallbackQueryEventArgs e)
{
var cbid = e.CallbackQuery.Id;
var user = e.CallbackQuery.From.Username;
var cid = e.CallbackQuery.Message.Chat.Id;
var mid = e.CallbackQuery.Message.MessageId;
var data = e.CallbackQuery.Data;
var text = e.CallbackQuery.Message.Text;
var chat = e.CallbackQuery.ChatInstance;
if (!string.IsNullOrEmpty(data))
{
if (data == "yes")
{
Voit++;
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new [] // first row
{
InlineKeyboardButton.WithCallbackData("1.1"),
InlineKeyboardButton.WithCallbackData("1.2"),
},
new [] // second row
{
InlineKeyboardButton.WithCallbackData("2.1"),
InlineKeyboardButton.WithCallbackData("2.2"),
}
});
await bot.AnswerCallbackQueryAsync(cbid, "Ваш голос принят!");
await bot.EditMessageTextAsync(cid, mid, $"Всего голосов:\n{Voit}");
await bot.EditMessageReplyMarkupAsync(
chatId : cid,
messageId : mid,
replyMarkup : inlineKeyboard
);
//await bot.EditMessageTextAsync(
// chatId: cid,
// messageId: mid,
// text: text,
// replyMarkup: inline
// );
}
else if (data == "no")
{
Voit--;
await bot.AnswerCallbackQueryAsync(cbid, "Ваш голос удален!");
}
//switch (data)
//{
// case "yes":
// await bot.EditMessageTextAsync(cid, mid, $"{text}");
// break;
// case "no":
// await bot.EditMessageTextAsync(cid, mid, $"{data} is pressed");
// break;
// default:
// break;
//}
}
}
private static void Bot_OnMessage(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
//file jonatishni boshlang'ichi
//var stream = new FileStream(@"C:\Users\User\Desktop\1.jpg", FileMode.Open); // faylni yuklab olindi
//var fileToSend = new FileToSend("asdasdas", stream); //filetosendga fileni tiqildi
var RequestReplyKeyboard = new ReplyKeyboardMarkup(new[]// bu yerda location qabul qilish ishlatilvotdi
{
new KeyboardButton("Location")
{
RequestLocation = true
} //keyboard bilan locationi qabul qilinvotdi
});
// key board yasash
var rkm = new ReplyKeyboardMarkup();
rkm.Keyboard =
new KeyboardButton[][]
{
new KeyboardButton[]
{
new KeyboardButton("item"),
new KeyboardButton("item")
},
new KeyboardButton[]
{
new KeyboardButton("item")
}
};
var RequestReplyKeyboard = new ReplyKeyboardMarkup(new[]// bu yerda location qabul qilish ishlatilvotdi
{
new KeyboardButton("Location")
{
RequestLocation = true
} //keyboard bilan locationi qabul qilinvotdi
});
RequestReplyKeyboard.ResizeKeyboard = true; // keyboart buttoni razmerini kichkina qiladi
Bot.SendTextMessageAsync(e.Message.Chat.Id, "Text", ParseMode.Default, false, false, 0, rkm);
//inline yasash
var inlineKeyboard = new InlineKeyboardMarkup(new[] { new[] { InlineKeyboardButton.WithCallbackData("asdas") },
new[] { InlineKeyboardButton.WithCallbackData("asdasdd") },
new[] { InlineKeyboardButton.WithCallbackData("asdasd") } });
Bot.SendTextMessageAsync(e.Message.Chat.Id, "-->", replyMarkup: inlineKeyboard);
//var result = Bot.SendTextMessageAsync(e.Message.Chat.Id, "Who or Where are you?", replyMarkup: RequestReplyKeyboard);
//Console.WriteLine(e.Message.Location.Longitude+ " :Longitude " + e.Message.Location.Latitude+ " :Latitude"); //locationni langetud va latetudesini consolga yozilvotdi
//Bot.SendPhotoAsync(e.Message.Chat.Id, fileToSend);// file jonatildi
//Console.WriteLine(e.Message.Date);
if (e.Message.Location != null)
{
Bot.SendLocationAsync(e.Message.Chat.Id, e.Message.Location.Latitude, e.Message.Location.Longitude);
}
if (e.Message.Type == Telegram.Bot.Types.Enums.MessageType.TextMessage)
{
//Bot.SendPhotoAsync(e.Message.Chat.Id, fileToSend);
Console.WriteLine(e.Message.Chat.Id + " " + e.Message.Text);
}
}
private static async Task BotOnMessageReceived(Message message)
{
Console.WriteLine($"Receive message type: {message.Type}");
if (message.Type != MessageType.Text)
{
return;
}
if (IsRequest)
{
if (Count == -1)
{
IsRequest = false;
Count = 7;
GoogleSheetsInterference.AppendList(ListName, Data);
var keyboard = new InlineKeyboardMarkup(new[]
{
new[] { InlineKeyboardButton.WithCallbackData("Назад", "/internships") }
});
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : $"Заявка на вакансию {ListName} успешно отправлена!",
replyMarkup : keyboard
);
Data = new List <object>();
ListName = null;
}
else
{
if (Count == 7)
{
Data = new List <object> {
message.Chat.Username, message.Date.ToString(CultureInfo.InvariantCulture)
};
Count = 5;
}
Data.Add(message.Text);
await Bot.SendTextMessageAsync(
chatId : message.Chat.Id,
text : $"{Props[Count]}"
);
Count--;
}
}
else
{
var action = message.Text.Split(' ').First() switch
{
"/start" => StartMessage(message),
_ => StartMessage(message)
};
await action;
}
private async static void BotOnMessageReceived(object sender, MessageEventArgs e)
{
var message = e.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
string name = $"{message.From.FirstName } {message.From.LastName}";
Console.WriteLine($"{name} sent text: '{message.Text}'");
User userrr = new User();
ClassStatusList st = JsonConvert.DeserializeObject <ClassStatusList>(File.ReadAllText(stpath));
int index = 0;
bool contains = false;
UserStatus usrstatus = new UserStatus();
for (int i = 0; i < st.statuses.Count; i++)
{
if (st.statuses[i].Id == Convert.ToString(message.From.Id))
{
contains = true;
usrstatus = st.statuses[i];
index = i;
break;
}
}
if (contains == false)
{
usrstatus.status1 = 0;
usrstatus.status2 = 0;
usrstatus.Id = Convert.ToString(message.From.Id);
st.statuses.Add(usrstatus);
}
switch (st.statuses[index].status1)
{
case 0:
{
switch (message.Text)
{
case "/start":
{
string text =
@"Список команд:
/gettoptracks - Топ-10 треков
/gettrack - Найти трек по названию
/getartistinfo - Информация об исполнителе
/getfavorite - Список избранных";
await Bot.SendTextMessageAsync(message.From.Id, text);
usrstatus.status1 = 0;
usrstatus.status2 = 0;
usrstatus.Id = Convert.ToString(message.From.Id);
st.statuses[index] = usrstatus;
File.WriteAllText(stpath, JsonConvert.SerializeObject(st));
break;
}
case "/gettoptracks":
{
var json = JsonConvert.SerializeObject(userrr);
var data = new StringContent(json, Encoding.UTF8, "application/json");
userrr.Id = Convert.ToString(message.From.Id);
HttpClient client = new HttpClient();
var response = await client.PostAsync($"https://localhost:44348/api/Music/GetTopTracks", data);
string result = response.Content.ReadAsStringAsync().Result;
ClassTracks useritem = JsonConvert.DeserializeObject <ClassTracks>(result);
List <List <InlineKeyboardButton> > inlineKeyboardList = new List <List <InlineKeyboardButton> >();
foreach (var track in useritem.tracks.track)
{
//if (track.url.Length <= 60)
{
List <InlineKeyboardButton> ts = new List <InlineKeyboardButton>();
ts.Add(InlineKeyboardButton.WithUrl(track.name + " - " + track.artist.name, track.url));
ts.Add(InlineKeyboardButton.WithCallbackData("+", Convert.ToString(message.From.Id) + "⁜" + track.name + "⁜" + track.artist.name));
inlineKeyboardList.Add(ts);
}
}
var inline = new InlineKeyboardMarkup(inlineKeyboardList);
await Bot.SendTextMessageAsync(message.From.Id, "Топ-10 треков:", replyMarkup : inline);
usrstatus.status1 = 0;
usrstatus.status2 = 1;
st.statuses[index] = usrstatus;
File.WriteAllText(stpath, JsonConvert.SerializeObject(st));
break;
}
case "/getartistinfo":
{
await Bot.SendTextMessageAsync(e.Message.Chat.Id, "Введите исполнителя");
st.statuses[index].status1 = 1;
File.WriteAllText(stpath, JsonConvert.SerializeObject(st));
break;
}
case "/gettrack":
{
await Bot.SendTextMessageAsync(e.Message.Chat.Id, "Введите название песни");
st.statuses[index].status1 = 2;
File.WriteAllText(stpath, JsonConvert.SerializeObject(st));
break;
}
case "/getfavorite":
{
userrr.Id = Convert.ToString(message.From.Id);
var json = JsonConvert.SerializeObject(userrr);
var data = new StringContent(json, Encoding.UTF8, "application/json");
HttpClient client = new HttpClient();
var response = await client.PostAsync($"https://localhost:44348/api/Music/GetFavorite", data);
string result = response.Content.ReadAsStringAsync().Result;
if (result == "BAD")
{
await Bot.SendTextMessageAsync(e.Message.Chat.Id, "Списка нету");
break;
}
List <SearchTrackMain> js = JsonConvert.DeserializeObject <List <SearchTrackMain> >(result);
List <List <InlineKeyboardButton> > inlineKeyboardList = new List <List <InlineKeyboardButton> >();
foreach (var track in js)
{
List <InlineKeyboardButton> ts = new List <InlineKeyboardButton>();
ts.Add(InlineKeyboardButton.WithUrl(track.name + " - " + track.artist, track.url));
ts.Add(InlineKeyboardButton.WithCallbackData("х", Convert.ToString(message.From.Id) + "⁜" + track.name + "⁜" + track.artist));
inlineKeyboardList.Add(ts);
}
var inline = new InlineKeyboardMarkup(inlineKeyboardList);
if (js.Count != 0)
{
await Bot.SendTextMessageAsync(message.From.Id, "Список фаворитов:", replyMarkup : inline);
}
else
{
await Bot.SendTextMessageAsync(message.From.Id, "Список фаворитов пуст.");
}
usrstatus.status1 = 0;
usrstatus.status2 = 2;
st.statuses[index] = usrstatus;
File.WriteAllText(stpath, JsonConvert.SerializeObject(st));
break;
}
default:
{
break;
}
}
break;
}
case 1: //для getartistinfo
{
try
{
st.statuses[index].status1 = 0;
File.WriteAllText(stpath, JsonConvert.SerializeObject(st));
userrr.Id = Convert.ToString(message.From.Id);
userrr.Artist = e.Message.Text;
var json = JsonConvert.SerializeObject(userrr);
var data = new StringContent(json, Encoding.UTF8, "application/json");
HttpClient client = new HttpClient();
var response = await client.PostAsync($"https://localhost:44348/api/Music/GetArtistInfo", data);
string result = response.Content.ReadAsStringAsync().Result;
ClassListArtistInfo useritem = JsonConvert.DeserializeObject <ClassListArtistInfo>(result);
await Bot.SendTextMessageAsync(message.From.Id, $"Artist: {useritem.artist.name}\n\nBio: {useritem.artist.bio.summary}.");
break;
}
catch
{
await Bot.SendTextMessageAsync(message.From.Id, "Было введено некорректное имя исполнителя.");
break;
}
}
case 2: //для gettrack
{
st.statuses[index].status1 = 0;
st.statuses[index].status2 = 1;
userrr.Id = Convert.ToString(message.From.Id);
userrr.Name = e.Message.Text;
var json = JsonConvert.SerializeObject(userrr);
var data = new StringContent(json, Encoding.UTF8, "application/json");
HttpClient client = new HttpClient();
var response = await client.PostAsync($"https://localhost:44348/api/Music/GetTrack", data);
string result = response.Content.ReadAsStringAsync().Result;
ClassResults useritem = JsonConvert.DeserializeObject <ClassResults>(result);
List <List <InlineKeyboardButton> > inlineKeyboardList = new List <List <InlineKeyboardButton> >();
foreach (var track in useritem.results.trackmatches.track)
{
if (track.url.Length <= 60)
{
List <InlineKeyboardButton> ts = new List <InlineKeyboardButton>();
ts.Add(InlineKeyboardButton.WithUrl(track.name + " - " + track.artist, track.url));
ts.Add(InlineKeyboardButton.WithCallbackData("+", Convert.ToString(message.From.Id) + "⁜" + track.name + "⁜" + track.artist));
inlineKeyboardList.Add(ts);
}
}
var inline = new InlineKeyboardMarkup(inlineKeyboardList);
if (result == "It's bad")
{
await Bot.SendTextMessageAsync(message.From.Id, "Ничего не найдено. Попробуйте ввести название по-другому.");
}
else
{
await Bot.SendTextMessageAsync(message.From.Id, "Найденные треки:", replyMarkup : inline);
}
File.WriteAllText(stpath, JsonConvert.SerializeObject(st));
break;
}
default:
{
goto case 0;
}
}
}
private static async void OnMessageHandlet(object sender, MessageEventArgs e)
{
var msg = e.Message;
string[] answers;
int indexCorrectAnswer;
InlineKeyboardButton[] ikb;
InlineKeyboardMarkup ikm;
ReplyKeyboardMarkup rkm = new ReplyKeyboardMarkup();
switch (msg.Text)
{
case "/start":
Console.WriteLine($"Входящее: ({msg.Chat.Username}) — НОВЫЙ");
rkm.Keyboard = new KeyboardButton[][]
{
new KeyboardButton[]
{
new KeyboardButton("🏁 Начать игру")
}
};
await client.SendTextMessageAsync(msg.Chat.Id, @"Добро пожаловать!
Этот бот позволит Вам немного напрячь свой мозг несложной математикой.
Попробуй если не струсил...", replyMarkup : rkm);
break;
case "🔄 Обновить пример":
try
{
await client.DeleteMessageAsync(msg.Chat.Id, msg.MessageId - 1);
}catch {}
try
{
await client.DeleteMessageAsync(msg.Chat.Id, msg.MessageId);
}
catch { }
anEquationAndAnswers.FormAnEquationAndAnswers(); //Создаётся новое уравнение и ответы
answers = anEquationAndAnswers.GetAnswers();
indexCorrectAnswer = anEquationAndAnswers.GetIndexCorrectAnswer();
ikb = new InlineKeyboardButton[3];
for (int i = 0; i < answers.Length; i++)
{
ikb[i] = InlineKeyboardButton.WithCallbackData(answers[i].ToString(), (i == indexCorrectAnswer) ? $"True|{answers[indexCorrectAnswer]}" : $"False|{answers[indexCorrectAnswer]}|{answers[i]}");
}
ikm = new InlineKeyboardMarkup(ikb);
await client.SendTextMessageAsync(msg.Chat.Id, anEquationAndAnswers.GetEquation(), replyMarkup : ikm);
break;
case "🏁 Начать игру":
anEquationAndAnswers.FormAnEquationAndAnswers(); //Создаётся новое уравнение и ответы
answers = anEquationAndAnswers.GetAnswers();
indexCorrectAnswer = anEquationAndAnswers.GetIndexCorrectAnswer();
ikb = new InlineKeyboardButton[3];
for (int i = 0; i < answers.Length; i++)
{
ikb[i] = InlineKeyboardButton.WithCallbackData(answers[i].ToString(), (i == indexCorrectAnswer) ? $"True|{answers[indexCorrectAnswer]}" : $"False|{answers[indexCorrectAnswer]}|{answers[i]}");
}
ikm = new InlineKeyboardMarkup(ikb);
rkm.Keyboard = new KeyboardButton[][]
{
new KeyboardButton[]
{
new KeyboardButton("🔄 Обновить пример")
}
};
await client.SendTextMessageAsync(msg.Chat.Id, "Хорошей игры 🎲", replyMarkup : rkm);
await client.SendTextMessageAsync(msg.Chat.Id, anEquationAndAnswers.GetEquation(), replyMarkup : ikm);
break;
default:
return;
}
}
/// <summary>
/// Обработчик сообщения боту
/// </summary>
/// <param name="sender">Объект отправивший сигнал</param>
/// <param name="e">Событие отправки сообщения</param>
private static async void Bot_OnMessage(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
var message = e.Message;
if (message == null)
{
return; // если сообщение null выходим из метода
}
long chatId = message.Chat.Id; // идентификатор чата
// Получение и сохранение ботом фото, аудио, видео и документа (и отправка их назад пользователю)
switch (message.Type)
{
case MessageType.Photo: // пользователь прислал фото
string fileNamePhoto = message.Photo[message.Photo.Length - 1].FileUniqueId + ".jpeg"; // имя файла фото
string fileIdPhoto = message.Photo[message.Photo.Length - 1].FileId; // идентификатор файла фото
// Последнее фото в массиве PhotoSize является оригиналом
DownLoad(fileIdPhoto, fileNamePhoto);
// Отправка фото обратно
await Bot.SendPhotoAsync(chatId, fileIdPhoto);
break;
case MessageType.Audio: // пользователь прислал аудио
string fileNameAudio = message.Audio.Title + "." + message.Audio.MimeType.Split("/")[1]; // имя файла аудио
string fileIdAudio = message.Audio.FileId; // идентификатор файла аудио
DownLoad(fileIdAudio, fileNameAudio);
// Отправка аудио обратно
await Bot.SendAudioAsync(chatId, fileIdAudio);
break;
case MessageType.Video: // пользователь прислал видео
string fileNameVideo = message.Video.FileUniqueId + "." + message.Video.MimeType.Split("/")[1]; // имя файла видео
string fileIdVideo = message.Video.FileId; // идентификатор файла видео
DownLoad(fileIdVideo, fileNameVideo);
// Отправка аудио обратно
await Bot.SendVideoAsync(chatId, fileIdVideo);
break;
case MessageType.Document: // пользователь прислал документ
string fileNameDocument = message.Document.FileName; // имя файла документа
string fileIdDocument = message.Document.FileId; // идентификатор файла документа
DownLoad(fileIdDocument, fileNameDocument);
// Отправка аудио обратно
await Bot.SendDocumentAsync(chatId, fileIdDocument);
break;
case MessageType.Text:
// Если чат пользователя в игре, то играем
if (games.isFindId(chatId))
{
string city = message.Text; // город, который отправил пользователь
// Если пользователь решил выйти из игры
if (city.ToUpper() == "КОНЕЦ")
{
games.removeGame(chatId); // удаляем игру
return;
}
// Если город есть в "википедии" бота
if (games.returnGame(chatId).isWikiKnowCity(city))
{
string lastCityBot = games.returnGame(chatId).LastCityBotSay; // предыдущий названный ботом город
// Если бот уже называл город
if (!String.IsNullOrEmpty(lastCityBot))
{
if (char.ToUpper(lastCityBot[lastCityBot.Length - 1]) == 'Ь')
{
if (char.ToUpper(lastCityBot[lastCityBot.Length - 2]) != char.ToUpper(city[0]))
{
await Bot.SendTextMessageAsync(chatId, $"Город должен начинаться на букву '{lastCityBot[lastCityBot.Length - 2]}'!");
return;
}
}
else
{
if (char.ToUpper(lastCityBot[lastCityBot.Length - 1]) != char.ToUpper(city[0]))
{
await Bot.SendTextMessageAsync(chatId, $"Город должен начинаться на букву '{lastCityBot[lastCityBot.Length - 1]}'!");
return;
}
}
}
games.returnGame(chatId).delCitiyInWikiBOT(city); // удаляем город из общего списка городов ("википедии бота"), чтобы город не повторялся
games.returnGame(chatId).delCityInKnowBOT(city); // удаляем город из "базы знаний" бота
// Если город оканчивается на мягкий знак, то бот ищет в своей "базе знаний" город начинающийся на предпоследнюю букву
if (city[city.Length - 1] == 'ь')
{
city = games.returnGame(chatId).cityWhoBotKnow(city[city.Length - 2]);
}
else
{
city = games.returnGame(chatId).cityWhoBotKnow(city[city.Length - 1]);
}
// Если бот не может дать ответ то завершаем игру
if (String.IsNullOrEmpty(city))
{
await Bot.SendTextMessageAsync(chatId, "Молодец, выигрышь за тобой!");
await Bot.SendTextMessageAsync(chatId, "конец");
Console.WriteLine($"Выиграл! username: '******', имя: '{message.Chat.FirstName}', фамилия: {message.Chat.LastName}"); // логирование
games.removeGame(chatId); // удаляем игру
return;
}
games.returnGame(chatId).LastCityBotSay = city; // последний названный ботом город (для проверки следующего города, введенного пользователем)
string htmlCity = $"<i>{city}</i>";
await Bot.SendTextMessageAsync(chatId, htmlCity, parseMode : ParseMode.Html);
games.returnGame(chatId).delCitiyInWikiBOT(city); // удаляем город из общего списка городов ("википедии бота"), чтобы город не повторялся
games.returnGame(chatId).delCityInKnowBOT(city); // удаляем город из "базы знаний" бота
}
else
{
// Если города нет в "википедии" бота, либо его уже называли
await Bot.SendTextMessageAsync(chatId, $"Город '{city}' моя Википедия не знает! Возможно этот город уже называли.");
return;
}
return;
}
break;
default:
break;
}
if (message.Text == null)
{
return; // если текст сообщения null выходим из метода
}
// Сообщение от бота (в формате HTML)
var answerText = "Меня зовут Сказочник.\nЯ люблю общаться с людьми, рассказывать разные сказки и играть в 'Города'!\n\n" +
"<b>Выбери команду:</b>\n" +
"/start - <i>запуск бота</i>\n" +
"/menu - <i>вывод меню</i>";
switch (message.Text)
{
case "/start":
await Bot.SendTextMessageAsync(chatId, answerText, ParseMode.Html); // вывод начального сообщения
break;
case "/menu":
// Создаем меню (клавиатуру)
var inlineKeyboard = new InlineKeyboardMarkup(new[] {
new[] { InlineKeyboardButton.WithCallbackData(menu["Story"]) },
new[] { InlineKeyboardButton.WithCallbackData(menu["Sities"]) }
});
await Bot.SendTextMessageAsync(chatId, "<b>Чем займемся?</b>", parseMode : ParseMode.Html, replyMarkup : inlineKeyboard);
break;
default:
// Общение с ботом через DialogFlow
// Инициализируем аргументы ответа
SessionName session = SessionName.FromProjectSession(projectID, sessionID);
var queryInput = new QueryInput {
Text = new TextInput {
Text = message.Text,
LanguageCode = "ru-ru"
}
};
// Создаем ответ пользователю
DetectIntentResponse response = await dFlowClient.DetectIntentAsync(session, queryInput);
answerText = response.QueryResult.FulfillmentText;
if (answerText == "")
{
// Intents для непонятных боту фраз
queryInput.Text.Text = "непонятно";
}
// Создаем ответ пользователю, если введен непонятный вопрос (набор букв)
response = await dFlowClient.DetectIntentAsync(session, queryInput);
answerText = response.QueryResult.FulfillmentText;
Console.WriteLine($"Общается username: '******', имя: '{message.Chat.FirstName}', фамилия: {message.Chat.LastName}"); // логирование
await Bot.SendTextMessageAsync(chatId, answerText); // отправляем пользователю ответ
break;
}
}
private static async void Bot_OnMessage(object sender, Telegram.Bot.Args.MessageEventArgs e)
{
var message = e.Message;
if (message == null || message.Type != MessageType.Text)
{
return;
}
string name = $"{message.From.FirstName} {message.From.LastName}";
Console.WriteLine($"{name} отправил сообщение :'{message.Text}'");
switch (message.Text)
{
case "/start":
string text = "@Список команд: " +
"/start -запуск бота, " +
" /callback - вывод меню, " +
"/keyboard - вывод клавиатуры ";
await Bot.SendTextMessageAsync(message.From.Id, text);
break;
case "/callback":
var inlineKeyboard = new InlineKeyboardMarkup(new[]
{
new[]
{
InlineKeyboardButton.WithUrl("Rozetka", "https://rozetka.com.ua/"),
InlineKeyboardButton.WithUrl("Citrus", "https://www.citrus.ua/")
},
new[]
{
InlineKeyboardButton.WithCallbackData("Картинка"),
InlineKeyboardButton.WithCallbackData("Видео")
}
});
await Bot.SendTextMessageAsync(message.From.Id, "Выберите пункт меню", replyMarkup : inlineKeyboard);
break;
case "/keyboard":
var replyKeyboard = new ReplyKeyboardMarkup(new[]
{
new[]
{
new KeyboardButton("Привет"),
new KeyboardButton("Как делишки?")
},
new[]
{
new KeyboardButton("Контакт")
{
RequestContact = true
},
new KeyboardButton("Геолокация")
{
RequestLocation = true
}
}
}
);
await Bot.SendTextMessageAsync(message.Chat.Id, "Сообщение", replyMarkup : replyKeyboard);
break;
default:
var response = apiAi.TextRequest(message.Text);
string answer = response.Result.Fulfillment.Speech;
if (answer == "")
{
answer = "Сорри, но я тебя не понял";
}
await Bot.SendTextMessageAsync(message.From.Id, answer);
break;
}
}
private static async void OnMessage(object sender, MessageEventArgs e)
{
if (e.Message.Type == Telegram.Bot.Types.Enums.MessageType.Text && e.Message.Date.AddMinutes(1) > DateTime.UtcNow)
{
string messageText = e.Message.Text;
string lowerMessageText = messageText.ToLower();
long chatId = e.Message.Chat.Id;
// LearnedPhrases
if (lowerMessageText.Contains("/remove") && lowerMessageText.Length > 8)
{
int position = e.Message.Text.IndexOf("/remove") + 8;
string keyToRemove = lowerMessageText.Substring(position);
if (LearnedPhrases.ContainsKey(keyToRemove))
{
var valuesList = LearnedPhrases[keyToRemove];
if (valuesList.Count == 1)
{
LearnedPhrases.Remove(keyToRemove);
await Bot.SendTextMessageAsync(chatId, "Borrado!");
}
else
{
InlineKeyboardButton[][] buttons = new InlineKeyboardButton[valuesList.Count][];
for (int i = 0; i < valuesList.Count; i++)
{
var value = valuesList[i];
buttons[i] = new InlineKeyboardButton[] {
InlineKeyboardButton.WithCallbackData(
value,
string.Format("{0};#!{1}", keyToRemove, value.Substring(0, value.Length < 20 ? value.Length : 20))
)
};
}
var keyboardMarkup = new InlineKeyboardMarkup(buttons);
await Bot.SendTextMessageAsync(chatId, "Cual quieres eliminar?", replyMarkup : keyboardMarkup);
}
}
else
{
await Bot.SendTextMessageAsync(chatId, "No he encontrado esa frase para borrar");
}
}
else if (lowerMessageText.ContainsAll(new List <string>()
{
"amigo", "aprende a contestar"
}))
{
int position = e.Message.Text.IndexOf("aprende a contestar") + 20;
List <string> nuevaFrase = new List <string>();
bool learned = false;
foreach (Match match in Regex.Matches(messageText, "\"([^\"]*)\""))
{
nuevaFrase.Add(match.ToString());
}
if (nuevaFrase.Count == 2)
{
string key = nuevaFrase.Last().ToLower().Replace("\"", string.Empty).Trim();
string value = nuevaFrase.First().Replace("\"", string.Empty).Trim();
if (!string.IsNullOrEmpty(key) &&
!string.IsNullOrEmpty(value) &&
key.Length >= 3)
{
if (LearnedPhrases.ContainsKey(key))
{
if (LearnedPhrases[key].Contains(value))
{
await Bot.SendTextMessageAsync(chatId, "Esta ya me la sabía!");
}
else
{
LearnedPhrases[key].Add(value);
}
}
else
{
LearnedPhrases.Add(key, new List <string>()
{
value
});
}
await Bot.SendTextMessageAsync(chatId, "Aprendido!");
System.IO.File.WriteAllText(LearnedPhrasesPath, JsonConvert.SerializeObject(LearnedPhrases));
learned = true;
}
}
if (!learned)
{
await Bot.SendTextMessageAsync(chatId, "Eso no lo he podido aprender...");
}
}
else if (lowerMessageText.ContainsAll(new List <string>()
{
"amigo", "di:"
}))
{
int position = e.Message.Text.IndexOf("di:") + 3;
await Bot.SendTextMessageAsync(chatId, e.Message.Text.Substring(position));
}
else if (lowerMessageText.ContainsAny(LearnedPhrases.Keys))
{
foreach (var key in lowerMessageText.GetAllContainingKeysIn(LearnedPhrases.Keys.ToList()))
{
var valuesList = LearnedPhrases[key];
int randomPosition = random.Next(valuesList.Count);
await Bot.SendTextMessageAsync(chatId, valuesList[randomPosition]);
}
}
// SPAM
if (lowerMessageText.Contains("/start") &&
(e.Message.Chat.Type == Telegram.Bot.Types.Enums.ChatType.Group ||
e.Message.Chat.Type == Telegram.Bot.Types.Enums.ChatType.Supergroup))
{
await Bot.SendTextMessageAsync(chatId, "Quereis empezar una partida? Eso merece un buen patataspam!!");
await SpamAdmins(chatId);
}
else if (lowerMessageText.Contains("patataspa") &&
(e.Message.Chat.Type == Telegram.Bot.Types.Enums.ChatType.Group ||
e.Message.Chat.Type == Telegram.Bot.Types.Enums.ChatType.Supergroup))
{
await SpamAdmins(chatId);
}
}
}
