private InlineKeyboardMarkup getWeekDaysKeyboard(WeekDays wd)
{
List <IEnumerable <InlineKeyboardButton> > buttons = new List <IEnumerable <InlineKeyboardButton> >();
List <InlineKeyboardButton> daysButtonsRow = new List <InlineKeyboardButton>();
foreach (WeekDays day in Enum.GetValues(typeof(WeekDays)))
{
string dayName = Enum.GetName(typeof(WeekDays), day);
bool dayChecked = (wd & day) > 0;
string buttonText = (dayChecked ? "+" : "-") + dayName;
daysButtonsRow.Add(new InlineKeyboardButton()
{
Text = buttonText, CallbackData = dayName
});
}
buttons.Add(daysButtonsRow);
buttons.Add(new List <InlineKeyboardButton>()
{
new InlineKeyboardButton()
{
Text = "Done", CallbackData = SelectDaysDone
}
});
buttons.Add(TelegramHelper.GetHomeButton());
return(new InlineKeyboardMarkup(buttons));
}
public ActionResult OnPost()
{
base.Init();
JsonResult result = new JsonResult("Error sending Telegram message.");
MemoryStream stream = new MemoryStream();
Request.Body.CopyTo(stream);
stream.Position = 0;
using (StreamReader reader = new StreamReader(stream)) {
string requestBody = reader.ReadToEnd();
if (requestBody.Length > 0)
{
TestTelegramForm tf = JsonConvert.DeserializeObject <TestTelegramForm>(requestBody);
if (tf != null)
{
TelegramHelper.SendMessage(tf.Telegram_BotToken.Trim(), tf.Telegram_ChatId, "PT Magic Telegram test message.", tf.Telegram_SilentMode.Equals("on"), Log);
result = new JsonResult("Success");
}
}
}
return(result);
}
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));
}
}
}
}
public TelegramLoginProvider(
TelegramHelper telegramHelper,
TenantManager tenantManager,
CoreBaseSettings coreBaseSettings,
CoreSettings coreSettings,
IConfiguration configuration,
ICacheNotify <ConsumerCacheItem> cache,
ConsumerFactory consumerFactory,
string name, int order, Dictionary <string, string> props, Dictionary <string, string> additional = null)
: base(tenantManager, coreBaseSettings, coreSettings, configuration, cache, consumerFactory, name, order, props, additional)
{
TelegramHelper = telegramHelper;
}
public void Execute()
{
if (CheckMessagingWorks() == false)
{
throw new Exception("Watch previous error.");
}
while (true)
{
DebugHelper.LogInfo("Search termin.");
var hasTermin = false;
try
{
hasTermin = _terminChecker.HasTermin();
}
catch (Exception ex)
{
DebugHelper.LogError(ex.Message);
}
if (hasTermin)
{
DebugHelper.LogSuccess("Termin finded!");
DebugHelper.LogInfo($"Sending info...");
if (!string.IsNullOrEmpty(_config.ToEmail))
{
EmailHelper.SendEmail(_emailConfig,
_config.ToEmail,
MessageText.TerminFindedSubject,
MessageText.TerminFindedMessage(_config.TerminUri));
}
if (!string.IsNullOrEmpty(_config.ToTelegram))
{
TelegramHelper.SendMessage(_telegramConfig,
_config.ToTelegram,
MessageText.TerminFindedMessage(_config.TerminUri));
}
}
else
{
DebugHelper.LogInfo("Termin not finded.");
}
Task.Delay(TimeSpan.FromMinutes(_config.PeriodInMinutes)).Wait();
}
}
private bool CheckMessagingWorks()
{
var isValid = true;
if (string.IsNullOrEmpty(_config.ToEmail.Trim()) &&
string.IsNullOrEmpty(_config.ToTelegram.Trim()))
{
DebugHelper.LogError("Not found email or telegram info.\n" +
"Please, input needed information in appSettings.json file.");
isValid = false;
}
if (!string.IsNullOrEmpty(_config.ToEmail))
{
var emailWorks = EmailHelper.SendEmail(_emailConfig,
_config.ToEmail,
MessageText.TestMessageSubject,
MessageText.TestMailMessage);
if (emailWorks == false)
{
DebugHelper.LogError($"Failed to send test message to email: {_config.ToEmail}.");
isValid = false;
}
}
if (!string.IsNullOrEmpty(_config.ToTelegram))
{
var telegaWorks = TelegramHelper.SendMessage(_telegramConfig,
_config.ToTelegram,
MessageText.TestTelegramMessage);
if (telegaWorks == false)
{
DebugHelper.LogError($"Failed to send test message to telegram: {_config.ToTelegram}.");
isValid = false;
}
}
return(isValid);
}
public async Task Initialize(ITelegramBotClient client, Update update)
{
long chatId = update.GetChatId();
List <IEnumerable <InlineKeyboardButton> > buttons = new List <IEnumerable <InlineKeyboardButton> >();
Repository.Model.Chat chat;
if (Program.RemindersRepository.TryGetChat(chatId, out chat))
{
foreach (Reminder reminder in chat.Reminders.OrderBy(r => r.DayTime))
{
buttons.Add(new List <InlineKeyboardButton>()
{
new InlineKeyboardButton()
{
Text = reminder.MessageText, CallbackData = reminder.ReminderId.ToString()
}
});
}
}
buttons.Add(TelegramHelper.GetHomeButton());
await client.SendTextMessageAsync(chatId, "Select reminder to remove", replyMarkup : new InlineKeyboardMarkup(buttons));
}
public async Task ProcessUpdate(ITelegramBotClient client, Update update)
{
if (update.Type == UpdateType.Message)
{
string timeText = update.Message.Text;
TimeSpan time;
if (TelegramHelper.TryParseTime(timeText, out time))
{
long chatId = update.Message.Chat.Id;
int minutes = Convert.ToInt32((time - update.Message.Date.TimeOfDay).TotalMinutes / 15) * 15;
minutes = minutes > 720 ? minutes - 1440 : minutes < -720 ? minutes + 1440 : minutes;
TimeSpan timeZone = TimeSpan.FromMinutes(minutes);
Program.RemindersRepository.SetTimeZone(chatId, timeZone);
this.Finished = true;
await client.SendDefaultMessageAsync(chatId);
}
else
{
await client.SendTextMessageAsync(update.GetChatId(), "Could not parse time. Use 24-hour HHmm format.");
}
}
}
public TelegramSender(IOptionsMonitor <ILog> options, TelegramHelper telegramHelper)
{
log = options.Get("ASC");
TelegramHelper = telegramHelper;
}
public async Task Initialize(ITelegramBotClient client, Update update)
{
long chatId = update.GetChatId();
if (Program.RemindersRepository.ChatExists(chatId))
{
this.reminder = new Reminder();
this.reminder.ChatId = chatId;
await client.SendTextMessageAsync(chatId, "Enter new reminder name", replyMarkup : TelegramHelper.GetHomeButtonKeyboard());
}
}
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);
}
}
}
private void Menu_Callbacks(object sender, CallbackQueryEventArgs e)
{
Task.Run(() =>
{
string callbackData = e.CallbackQuery.Data;
string[] callbackDataSplitted = callbackData.Split(" ");
var rssUser = _userService.Get(x => x.TelegramId == e.CallbackQuery.From.Id);
if (callbackData == TelegramBotCommands.CALLBACK_SUBSCRIBE)
{
//will be rearanged with mongodb aggregation in order to query one time.
var userRssList = _userRssService.GetList(x => x.UserId == rssUser.Id);
var userGroupCount = _telegramGroupService.GetCollection().Count(x => x.UserId == rssUser.Id);
var userSubscribeList = _userSubscribeService.GetList(x => x.UserId == rssUser.Id);
userRssList = userRssList.Where(x => (userSubscribeList.Count(y => y.RssId == x.Id) < userGroupCount)).ToList();
var customRssMenu = userRssList.ToMenu(TelegramBotCommands.KEY_RSS_SUBSCRIBE);
_telegramBotClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, TelegramBotCommands.SUBSCRIBE_INFORMATION,
replyMarkup: customRssMenu);
}
else if (callbackData == TelegramBotCommands.CALLBACK_UNSUBSCRIBE)
{
//will be rearanged with mongodb aggregation in order to query one time.
var userRssList = _userRssService.GetList(x => x.UserId == rssUser.Id);
var userSubscribeList = _userSubscribeService.GetList(x => x.UserId == rssUser.Id);
userRssList = userRssList.Where(x => userSubscribeList.Any(y => y.RssId == x.Id)).ToList();
var customRssMenu = userRssList.ToMenu(TelegramBotCommands.KEY_RSS_UNSUBSCRIBE);
_telegramBotClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, TelegramBotCommands.UNSUBSCRIBE_INFORMATION,
replyMarkup: customRssMenu);
}
else if (callbackData == TelegramBotCommands.CALLBACK_HOME)
{
_telegramBotClient.SendStartMenu(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId);
}
else if (callbackDataSplitted.CallbackIsEqualTo(TelegramBotCommands.KEY_RSS_SUBSCRIBE))
{
//will be rearanged with mongodb aggregation in order to query one time.
var userGroupList = _telegramGroupService.GetList(x => x.UserId == rssUser.Id);
var userSubscribeList = _userSubscribeService.GetList(x => x.UserId == rssUser.Id);
string rssId = callbackData.RemoveFirstChar().RemoveFirstChar();
userGroupList = userGroupList.Where(x => !userSubscribeList.Any(y => y.GroupId == x.Id && y.RssId == rssId)).ToList();
var customGroupMenu = userGroupList.ToMenu(string.Concat(TelegramBotCommands.KEY_RSS_SUBSCRIBE_GROUP, callbackData.RemoveFirstChar()));
_telegramBotClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, TelegramBotCommands.SUBSCRIBE_GROUP_INFORMATION,
replyMarkup: customGroupMenu, parseMode: ParseMode.Html);
}
else if (callbackDataSplitted.CallbackIsEqualTo(TelegramBotCommands.KEY_RSS_UNSUBSCRIBE))
{
//will be rearanged with mongodb aggregation in order to query one time.
var userGroupList = _telegramGroupService.GetList(x => x.UserId == rssUser.Id);
var userSubscribeList = _userSubscribeService.GetList(x => x.UserId == rssUser.Id);
string rssId = callbackData.RemoveFirstChar().RemoveFirstChar();
userGroupList = userGroupList.Where(x => userSubscribeList.Any(y => y.GroupId == x.Id && y.RssId == rssId)).ToList();
var customGroupMenu = userGroupList.ToMenu(string.Concat(TelegramBotCommands.KEY_RSS_UNSUBSCRIBE_GROUP, " ", callbackData.RemoveFirstChar()));
_telegramBotClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, TelegramBotCommands.UNSUBSCRIBE_GROUP_INFORMATION,
replyMarkup: customGroupMenu);
}
else if (callbackDataSplitted.CallbackIsEqualTo(TelegramBotCommands.KEY_RSS_SUBSCRIBE_GROUP))
{
string[] Ids = callbackData.RemoveFirstChar().Split(" ", StringSplitOptions.RemoveEmptyEntries);
//Index 0: RSS
//Index 1: GROUP
_userSubscribeService.Save(new dal.entities.UserSubscribe
{
UserId = rssUser.Id,
GroupId = Ids[1],
RssId = Ids[0],
});
_telegramBotClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, TelegramBotCommands.USER_SUBSCRIBE_INFORMATION
, replyMarkup: TelegramHelper.CreateMenu(TelegramMenu.BUTTONS_SUBSCRIBE_UNSUBSCRIBE));
}
else if (callbackDataSplitted.CallbackIsEqualTo(TelegramBotCommands.KEY_RSS_UNSUBSCRIBE_GROUP))
{
string[] Ids = callbackData.RemoveFirstChar().Split(" ", StringSplitOptions.RemoveEmptyEntries);
//Index 0: RSS
//Index 1: GROUP
_userSubscribeService.Delete(x => x.RssId == Ids[0] && x.UserId == rssUser.Id && x.GroupId == Ids[1]);
_telegramBotClient.EditMessageTextAsync(e.CallbackQuery.From.Id, e.CallbackQuery.Message.MessageId, TelegramBotCommands.USER_UNSUBSCRIBE_INFORMATION
, replyMarkup: TelegramHelper.CreateMenu(TelegramMenu.BUTTONS_SUBSCRIBE_UNSUBSCRIBE));
}
});
}
public async Task Initialize(ITelegramBotClient client, Update update)
{
await client.SendTextMessageAsync(update.GetChatId(),
"Enter your current local time to detect your timezone. Use 24-hour HHmm format.",
replyMarkup : TelegramHelper.GetHomeButtonKeyboard());
}
