private async Task HandleAuthenticatedUserDelCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
UnStop(userId);
if (parsedCommand.Length < 2 || !int.TryParse(parsedCommand[1], out var idx))
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, please give arguments to the command");
return;
}
var state = UserState <UserRssSubscriptions> .LoadOrDefault(userId);
if (state.Data.RssEntries == null || idx >= state.Data.RssEntries.Count || idx < 0)
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, index {idx} is not known");
return;
}
state.Data.RssEntries.RemoveAt(idx);
state.Save();
var r = await api.RespondToUpdate(update, $"{from.FirstName}, {idx} was removed");
}
private async Task HandleNonAuthenticatedUserCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
if (parsedCommand.Length == 2 &&
parsedCommand[0] == "/auth" &&
parsedCommand[1] == Configuration.BOT_SECRET)
{
var state = UserState <UserDetails> .LoadOrDefault(userId);
state.Data.ChatId = chat.Id;
state.Data.UserId = userId; // kind of overkill
state.Save();
var r = await api.RespondToUpdate(update, $"{from.FirstName}, you are now authenticated");
}
else if (parsedCommand.Length > 1 && parsedCommand[0] == "/start")
{
await HandleUnauthenticatedUserStartCommand(api, update, from, chat, userId, parsedCommand);
}
else
{
var r = await api.RespondToUpdate(update, $"{from.FirstName}, access denied");
}
}
private async Task HandleAuthenticatedUserHoursCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
var state = UserState <UserMuteState> .LoadOrDefault(userId);
if (parsedCommand.Length != 3 ||
!int.TryParse(parsedCommand[1], out var hoursFrom) ||
!int.TryParse(parsedCommand[2], out var hoursTo))
{
var r1 = await api.RespondToUpdate(update, $"{from.FirstName}, I need arguments");
return;
}
state.Data.SetHours(hoursFrom, hoursTo);
state.Save();
var r = await api.RespondToUpdate(update, $"{from.FirstName}, bot will mute notifications when outside [{hoursFrom}:00:00, {hoursTo}:00:00]");
}
private async Task HandleAuthenticatedUserListCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
UnStop(userId);
var state = UserState <UserRssSubscriptions> .LoadOrDefault(userId);
var r = await api.RespondToUpdate(update, $"{from.FirstName}, here are your subscribtions:");
if (state.Data.RssEntries != null)
{
for (int i = 0; i < state.Data.RssEntries.Count; ++i)
{
var entry = state.Data.RssEntries[i];
var kws = string.Join(", ", entry.Keywords);
var rr = await api.RespondToUpdate(update, $"{i}: {entry.Url} {kws}");
}
}
}
public TelegramBotCore(ITelegramBotApi api, int numWorkers)
{
_api = api;
_queue = new Queue <Telegram.Update>();
_queueLock = new object();
NumWorkers = numWorkers;
_taskArray = new Task[NumWorkers + 1];
}
private async Task HandleAuthenticatedUserCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
switch (parsedCommand[0])
{
case "/help":
await HandleAuthenticatedUserHelpCommand(api, update, from, chat, userId, parsedCommand);
break;
case "/add":
await HandleAuthenticatedUserAddCommand(api, update, from, chat, userId, parsedCommand);
break;
case "/list":
await HandleAuthenticatedUserListCommand(api, update, from, chat, userId, parsedCommand);
break;
case "/del":
await HandleAuthenticatedUserDelCommand(api, update, from, chat, userId, parsedCommand);
break;
case "/stop":
await HandleAuthenticatedUserStopCommand(api, update, from, chat, userId, parsedCommand);
break;
case "/words":
await HandleAuthenticatedUserWordsCommand(api, update, from, chat, userId, parsedCommand);
break;
case "/mute":
await HandleAuthenticatedUserMuteCommand(api, update, from, chat, userId, parsedCommand);
break;
case "/unmute":
await HandleAuthenticatedUserUnmuteCommand(api, update, from, chat, userId, parsedCommand);
break;
default:
await HandleAuthenticatedUserUnknownCommand(api, update, from, chat, userId, parsedCommand);
break;
}
}
public TelegramBotCore(ITelegramBotApi api, int numWorkers = 10)
{
_api = api;
_queue = new Queue <Update>();
_queueLock = new object();
_queueCount = new SemaphoreSlim(0);
NumWorkers = numWorkers;
_taskArrayLock = new object();
}
private async Task HandleAuthenticatedUserUnknownCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
var r = await api.RespondToUpdate(update,
$"Hello {from.FirstName}, I cannot understand {parsedCommand[0]}, try asking for /help");
}
public RssTelegramBot(ITelegramBotApi api,
IRssReader rssReader,
int refreshIntervalSeconds = 600,
int numWorkers = 10,
int numRssUpdateWorkers = 10
)
: base(api, numWorkers)
{
_refreshInterval = TimeSpan.FromSeconds(refreshIntervalSeconds);
_numRssUpdateWorkers = numRssUpdateWorkers;
_rssReader = rssReader;
}
private async Task HandleAuthenticatedUserUnmuteCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
var state = UserState <UserMuteState> .LoadOrDefault(userId);
state.Data.Muted = false;
state.Save();
var r = await api.RespondToUpdate(update, $"{from.FirstName}, bot un-muted");
}
private async Task HandleUnauthenticatedUserStartCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
var state = UserState <UserMuteState> .LoadOrDefault(userId);
state.Data.Stopped = true;
state.Save();
var r = await api.RespondToUpdate(update, $"Saluton {from.FirstName}. Estas propra boto, vi bezonas rajto pro uzi gxin");
}
private async Task HandleAuthenticatedUserHelpCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
var r = await api.RespondToUpdate(update,
$@"Hello {from.FirstName}, here are the commands I can understand:
/add <rss_url> [optional] [keywords]
- subscribe to the rss feed, with optional keywords to filter by
/list
- list current subscriptions
/del <number>
- delete subscription by the number
/words <number> [optional] [keywords]
- update the list of keywords for subscription index, keywords can be empty
/words add <number> <word>
- add a new keyword to subscription index
/words del <number> <word>
- del a keyword from subscription index
/mute
- mute everything, you would keep receiving updates but without any notifications
/unmute
- unmute everything
/hours <from> <to>
- set allowed notification hours, in 24 format, inclusive both, e.g. /hours 7 20 would
mean notifications are allowed from 7:00:00 to 20:00:00
/stop
- stop the bot completely, do any edit to un-stop it
GDPR PRIVACY NOTICE:
There is no privacy. Consider anything you send to this bot as public.
");
}
private async Task HandleNonAuthenticatedUserCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
if (parsedCommand.Length == 2 &&
parsedCommand[0] == "/auth" &&
parsedCommand[1] == ApiKeys.BOT_SECRET_AUTH_KEY)
{
UserState <AuthValidFlag> .LoadOrDefault(userId).Save();
var r = await api.RespondToUpdate(update, $"{from.FirstName}, you are now authenticated");
}
else
{
var r = await api.RespondToUpdate(update, $"{from.FirstName}, access denied");
}
}
private async Task HandleUserMessageAsync(ITelegramBotApi api, Update update)
{
User from = update.Message.From;
Chat chat = update.Message.Chat;
long userId = update.Message.From.Id;
string text = update.Message.Text ?? "";
string[] commandItems = text.Split(' ');
if (commandItems.Length < 1)
{
return;
}
if (UserState <UserDetails> .ExistsFor(userId) && UserState <UserDetails> .LoadOrDefault(userId).Data.AuthValid)
{
await HandleAuthenticatedUserCommand(api, update, from, chat, userId, commandItems);
}
else
{
await HandleNonAuthenticatedUserCommand(api, update, from, chat, userId, commandItems);
}
}
private async Task HandleAuthenticatedUserAddCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
UnStop(userId);
if (parsedCommand.Length < 2)
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, please give arguments to the command");
return;
}
var state = UserState <UserRssSubscriptions> .LoadOrDefault(userId);
if (state.Data.RssEntries == null)
{
state.Data.RssEntries = new List <RssUrlEntry>();
}
state.Data.RssEntries.Add(
new RssUrlEntry
{
Url = parsedCommand[1],
Keywords = parsedCommand.Skip(2).ToArray()
});
state.Save();
var r = await api.RespondToUpdate(update, $"{from.FirstName}, it was added");
}
internal abstract void HandleUserMessage(ITelegramBotApi api, Update msg);
internal override void HandleUserMessage(ITelegramBotApi api, Update update)
{
HandleUserMessageAsync(api, update).Wait();
}
private async Task HandleAuthenticatedUserWordsCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
UnStop(userId);
if (parsedCommand.Length < 2)
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, please give arguments to the command");
return;
}
var state = UserState <UserRssSubscriptions> .LoadOrDefault(userId);
if (int.TryParse(parsedCommand[1], out var idx))
{
if (state.Data.RssEntries == null || idx >= state.Data.RssEntries.Count || idx < 0)
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, index {idx} is not known");
return;
}
var keyWords = parsedCommand.Skip(2).Select(x => ParseKeyword(x)).ToHashSet();
state.Data.RssEntries[idx].Keywords = keyWords.ToArray();
state.Save();
var r = await api.RespondToUpdate(update, $"{from.FirstName}, {idx} was updated");
}
else if (parsedCommand[1] == "add" && parsedCommand.Length >= 4 &&
int.TryParse(parsedCommand[2], out var addIdx))
{
var addWords = parsedCommand.Select(x => ParseKeyword(x)).Skip(3);
if (state.Data.RssEntries == null || addIdx >= state.Data.RssEntries.Count || addIdx < 0)
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, index {addIdx} is not known");
return;
}
if (state.Data.RssEntries[idx].Keywords == null)
{
state.Data.RssEntries[idx].Keywords = addWords.ToArray();
}
else
{
var words = state.Data.RssEntries[idx].Keywords.ToHashSet();
foreach (var newWord in addWords)
{
words.Add(newWord);
}
state.Data.RssEntries[idx].Keywords = words.ToArray();
}
state.Save();
var r = await api.RespondToUpdate(update, $"{from.FirstName}, {idx} was updated");
}
else if (parsedCommand[1] == "del" && parsedCommand.Length >= 4 &&
int.TryParse(parsedCommand[2], out var delIdx))
{
var delWords = parsedCommand.Select(x => ParseKeyword(x)).Skip(3);
if (state.Data.RssEntries == null || delIdx >= state.Data.RssEntries.Count || delIdx < 0)
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, index {delIdx} is not known");
return;
}
if (state.Data.RssEntries[idx].Keywords != null)
{
var words = state.Data.RssEntries[idx].Keywords.ToHashSet();
foreach (var delWord in delWords)
{
words.Remove(delWord);
}
state.Data.RssEntries[idx].Keywords = words.ToArray();
}
state.Save();
var note = (state.Data.RssEntries[idx].Keywords == null ||
state.Data.RssEntries[idx].Keywords.Length == 0)
? ", WARNING: keyword list is not empty"
: "";
var r = await api.RespondToUpdate(update, $"{from.FirstName}, {idx} was updated{note}");
}
else
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, please give arguments to the command");
return;
}
}
public TelegramBot(ITelegramBotApi api, int numWorkers) : base(api, numWorkers)
{
}
private async Task HandleAuthenticatedUserAddCommand(
ITelegramBotApi api,
Update update,
User from,
Chat chat,
long userId,
string[] parsedCommand
)
{
UnStop(userId);
if (parsedCommand.Length < 2)
{
var rr = await api.RespondToUpdate(update, $"{from.FirstName}, please give arguments to the command");
return;
}
var state = UserState <UserRssSubscriptions> .LoadOrDefault(userId);
if (state.Data.RssEntries == null)
{
state.Data.RssEntries = new List <RssUrlEntry>();
}
var url = parsedCommand[1];
var keyboards = parsedCommand.Skip(2).Select(x => ParseKeyword(x)).ToArray();
if (state.Data.RssEntries.Find(x => x.Url == url) != null)
{
var re = await api.RespondToUpdate(update, $"{from.FirstName}, the URI {url} is already in your list");
return;
}
var rssParsed = await _rssReader.FetchAndParse(url);
if (rssParsed == null)
{
var re = await api.RespondToUpdate(update, $"{from.FirstName}, the URI {url} is not looking like a valid RSS");
return;
}
state.Data.RssEntries.Add(new RssUrlEntry {
Url = url, Keywords = keyboards
});
state.Save();
var rssPubDates = UserState <UserFeedPubDates> .LoadOrDefault(userId);
if (rssPubDates.Data.PubDates == null)
{
rssPubDates.Data.PubDates = new SerializableDictionary <string, DateTime>();
}
rssPubDates.Data.PubDates[url] = rssParsed.LastBuildDate;
try
{
rssPubDates.Save();
}
catch (Exception ex)
{
logger.Error(ex, "Exception while saving xml");
}
var r = await api.RespondToUpdate(update, $"{from.FirstName}, it was added");
}
public PluginContext(PluginInfo pluginInfo, ITelegramBotApi botApi)
{
_pluginInfo = pluginInfo;
BotApi = botApi;
}
