protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
var docent = PreferenceRegistry.GetRoosterForUser(m.From);
if (!m.HasArguments)
{
if (docent != null)
return Message(m, "Je hebt al een docentcode opgegeven.\n\rOm deze aan te passen, typ: '/docent [docentcode]'");
else
return Message(m, "Geef je docentcode op zoals deze op https://roosters.windesheim.nl/ staat, bijvoorbeeld: '/docent EES01'");
}
else
{
var docentStr = string.Join("", m.Arguments).ToLower();
foreach (Docent d in await WindesheimRoosterConvertor.GetDocentenLijst())
if (d.Name.ToLower() == docentStr)
{
var preferences = PreferenceRegistry.GetUserPreferencesForUser(m.From);
if (preferences.RoosterFor != null)
{
if(preferences.RoosterFor == d)
return Message(m, $"Je bent al gekoppeld aan de docent {d.Bold()}", userMarkup: true);
var roosterMessageFlow = new AddRoosterFlow(preferences, d);
m.From.MessageFlow = new MessageFlow(m.From, new FlowObject { Handler = roosterMessageFlow });
return roosterMessageFlow.DefaultReply(m);
}
else
{
preferences.RoosterFor = d;
return Message(m, $"Je bent gekoppeld aan de docent: {d.Bold()}");
}
}
return Message(m, $"De docentcode {string.Join(" ", m.Arguments)} kon ik niet vinden.");
}
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
if (IsInGame(m.From))
return Message(m, "You're allready in a game! Leave that one first.");
HostGame(m.From);
return Message(m, "You are now hosting a game. People can join you with the /join command", replyMarkup: HostKeyboard);
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
var preferences = PreferenceRegistry.GetUserPreferencesForUser(m.From);
var klassenLijst = await WindesheimRoosterConvertor.GetKlassenLijst();
if (!m.HasArguments)
{
if (preferences.RoosterFor != null)
return Message(m, AddingKlasFailed("Je hebt al een klas opgegeven.\n\rOm deze aan te passen, typ: '/klas [klasnaam]'"));
else
return Message(m, AddingKlasFailed("Geef je klas op zoals deze op https://roosters.windesheim.nl/ staat, bijvoorbeeld: '/klas ICTM1a'"));
}
else
{
var klasStr = string.Join("", m.Arguments).ToLower();
foreach (Klas k in klassenLijst)
if (k.Name.ToLower() == klasStr)
{
if (preferences.RoosterFor != null)
{
if (preferences.RoosterFor == k)
return Message(m, $"Je bent al gekoppeld aan de klas {k.Bold()}", userMarkup: true);
var roosterMessageFlow = new AddRoosterFlow(preferences, k);
m.From.MessageFlow = new MessageFlow(m.From, new FlowObject { Handler = roosterMessageFlow });
return roosterMessageFlow.DefaultReply(m);
}
else
{
PreferenceRegistry.GetUserPreferencesForUser(m.From).RoosterFor = k;
return Message(m, $"Je bent gekoppeld aan klas: {k.Name}");
}
}
return Message(m, AddingKlasFailed($"De klas {string.Join(" ", m.Arguments)} kon ik niet vinden."));
}
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
var roosterFor = PreferenceRegistry.GetRoosterForUser(m.From);
var preferences = PreferenceRegistry.GetUserPreferencesForUser(m.From);
if (roosterFor == null)
return Message(m, "Je hebt nog geen klas of docent gekoppeld!\n\rGebruik /klas om een klas te koppelen, en /docent om een docent te koppelen.");
var date = DateTime.Now;
var result = await WindesheimRoosterConvertor.GetRooster(preferences, date, restrictToDate: date);
var rooster = result.Rooster;
if (rooster.Lessen.Count == 0)
return Message(m, "Je hebt nu geen lessen.");
var nu = rooster.GetLesForTime(date, preferences.GetIgnoredLessen());
var na = rooster.GetFirstLesAfterTime(date, preferences.GetIgnoredLessen());
if (nu == null && na == null)
return Message(m, "Je hebt vandaag geen les meer!");
var nuDisplay = nu == null ? "Je hebt nu geen les!" : RoosterFormatProvider.Instance.FormatLes(nu, preferences);
var naDisplay = na == null ? "Je hebt hierna geen les!" : RoosterFormatProvider.Instance.FormatLes(na, preferences);
return Message(m,
$@"Nu:
{nuDisplay}
Straks:
{naDisplay}");
}
public TelegramBotReply Step1(Message m, MessageHandlerType type)
{
if (type != MessageHandlerType.Message)
return Message(m, "You can only use text as a description.");
Spoiler.Description = m.Text;
return Message(m, $"Okay, what is the spoiler?", replyMarkup: ForceReply.Instance);
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
if (m.Text == "Yes")
if (IsHost)
{
var byeMsg = Message(-1, "The host has quit. The game is no longer available", replyMarkup: SecretHitlerBot.DefaultKeyboard);
foreach (var player in game.Players)
if (player != user)
{
byeMsg.ChatId = player.ID;
await byeMsg.HandleReply(bot);
}
GameRegistry.RemoveGame(game);
return Message(m, "The game has ended", replyMarkup: SecretHitlerBot.DefaultKeyboard);
}
else
{
var leaveMsg = Message(-1, $"Player {user} left. The game can't continue. The host must restart the game");
foreach(var player in game.Players)
if(player != user)
{
leaveMsg.ChatId = player.ID;
await leaveMsg.HandleReply(bot);
}
game.Leave(m.From);
return Message(m, "You have left the game", replyMarkup: SecretHitlerBot.DefaultKeyboard);
}
else if (m.Text == "No")
return Message(m, "Okay, thanks for staying!", replyMarkup: IsHost ? HostMessageHandler.HostKeyboard : JoinMessageHandler.JoinedPlayerKeyboard);
MessageFlow.Failed();
return Message(m, "Invalid response, use the yes or no buttons", replyMarkup: LeaveMessageHandler.YesNoKeyboard);
}
public TelegramBotReply Step2(Message m, MessageHandlerType type)
{
Spoiler.Type = type;
switch (type)
{
case MessageHandlerType.Message:
Spoiler.Text = m.Text; break;
case MessageHandlerType.Sticker:
Spoiler.Sticker = m.Sticker; break;
case MessageHandlerType.Voice:
Spoiler.Voice = m.Voice; break;
case MessageHandlerType.Document:
Spoiler.Document = m.Document; break;
case MessageHandlerType.Audio:
Spoiler.Audio = m.Audio; break;
case MessageHandlerType.Location:
Spoiler.Location = m.Location; break;
case MessageHandlerType.Video:
Spoiler.Video = m.Video; break;
case MessageHandlerType.Photo:
Spoiler.Photo = m.Photo[m.Photo.Length - 1]; break;
default:
Spoiler.Type = MessageHandlerType.Unknown; break;
}
return Message(m,
$@"Okay the description is as follows:
{Spoiler.Description}
The spoiler that I'll keep secret is:
{GetDescription(Spoiler)}
Would you like to submit this to the group '{Group.Title}'", replyMarkup: keyboard);
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
m.Text = m.Text.ToLower().Trim();
if (m.Text.Length == 0)
m.From.MessageFlow.Failed();
else
{
foreach (var klas in await WindesheimRoosterConvertor.GetKlassenLijst())
if (klas.Name.ToLower() == m.Text)
{
PreferenceRegistry.GetUserPreferencesForUser(m.From).RoosterFor = klas;
return Message(m, $"Het is gelukt! Je bent gekoppeld aan: {klas.Name}\r\nJe kunt onderstaand toetsenbord gebruiken om je rooster met 1 klik op te vragen!\r\nGa je toch nog switchen van klas? Typ dan '/klas'.");
}
foreach(var docent in await WindesheimRoosterConvertor.GetDocentenLijst())
{
if (docent.Name.ToLower() == m.Text)
{
PreferenceRegistry.GetUserPreferencesForUser(m.From).RoosterFor = docent;
return Message(m, $"Het is gelukt! Je bent gekoppeld aan: {docent.DisplayName}\r\nJe kunt onderstaand toetsenbord gebruiken om je rooster met 1 klik op te vragen!\r\nBen je toch aan de verkeerde docent gekoppeld? Typ dan '/docent'.");
}
}
}
m.From.MessageFlow.Failed();
return null;
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
User u = null;
if (!m.HasArguments)
return Message(m, "Geen parameters");
else
{
Func<string, User, bool> func = null;
string searchString = (m.Arguments[0].Contains("@") ? m.Arguments[0].Substring(1) : m.Arguments[0]).ToLower();
if (m.Text.Contains("@"))
func = HasUserUsername;
else
func = HasUserName;
foreach(var user in PreferenceRegistry.GetUsers())
if(func(searchString, user))
{
u = user;
break;
}
if (u != null)
{
PreferenceRegistry.RemoveUser(u);
UserManager.Instance.RemoveValue(u);
return Message(m, $"Gebruiker {u} verwijderd.");
}
else
return Message(m, "Gebruiker niet gevonden");
}
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
GameRegistry.Game game;
if (!GameRegistry.IsInGame(m.From, out game))
return Message(m, "You are not in a game", replyMarkup: SecretHitlerBot.DefaultKeyboard);
m.From.MessageFlow = new MessageFlow(m.From, new FlowObject { Handler = new LeaveMessageConfirm(game, m.From) });
return Message(m, "Are you sure you want to leave?", replyMarkup: YesNoKeyboard);
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
GameRegistry.Game game;
if (!GameRegistry.IsInGame(m.From, out game))
return Message(m, "You are not in a game.");
return Message(m, $"Current players:\r\n - {(string.Join("\r\n - ", (IEnumerable<User>)game.Players))}");
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
var flow = MessageFlow.CurrentObject as CustomRoosterMessageFlowObject;
if (flow.DocentCount == 0 && flow.Klas == null)
return await Step1(bot, m, flow);
else if (flow.DocentCount > 1)
return Step2(bot, m, flow);
else
return await Step3(bot, m, flow);
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
if (m.Chat.IsChat) return null; //Niks doen met berichten in groepschats
if (Spoiler.Description == null)
return Step1(m, type);
else if (Spoiler.Type == MessageHandlerType.Unknown)
return Step2(m, type);
else
return await Step3(m, bot);
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
GameRegistry.Game game;
if (!GameRegistry.IsInGame(m.From, out game))
return Message(m, "You are not in a game");
if (game.Host != m.From)
return Message(m, "Only the host has access to this command");
var flow = new PickPlayerFlow(game, onPlayerPicked);
m.From.MessageFlow = new MessageFlow(m.From, new FlowObject { Handler = flow });
return Message(m, "Who may view someone's membership", replyMarkup: flow.GetKeyboard());
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
GameRegistry.Game game;
ReplyKeyboardMarkup keyboard;
if (!GameRegistry.IsInGame(m.From, out game))
keyboard = SecretHitlerBot.DefaultKeyboard;
else if (game.Host == m.From)
keyboard = HostMessageHandler.HostKeyboard;
else
keyboard = JoinMessageHandler.JoinedPlayerKeyboard;
return Message(m, "Unknown command", replyMarkup: keyboard);
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
foreach(var user in game.Players)
{
if(user.ToString() == m.Text)
{
var val = await onPlayerPicked(user, bot, m, game);
if (val != null)
return val;
MessageFlow.Failed();
return Message(m, "Wrong user", replyMarkup: GetKeyboard());
}
}
MessageFlow.Failed();
return Message(m, "Wrong user", replyMarkup: GetKeyboard());
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
if (!m.HasArguments)
return Message(m, "Je dient argumenten mee te geven voor een reply");
User user = null;
string username = null;
if (m.Arguments[0].Contains("@"))
{
username = m.Arguments[0].Substring(1).ToLower();
foreach (var u in PreferenceRegistry.GetUsers())
if (u.Username != null && u.Username.ToLower() == username)
{
user = u;
break;
}
}
else if (m.Text.Contains("[") && m.Text.Contains("]"))
{
username = m.Arguments[0].ToLower();
foreach(var u in PreferenceRegistry.GetUsers())
if(username == u.ToString().ToLower())
{
user = u;
break;
}
}
else
return Message(m, "Je moet beginnen met de username van de gebruiker: /reply @windesheimroosterbot [bericht]");
if (user == null)
return Message(m, $"De gebruiker @{username} is niet bekend.");
string[] msg = new string[m.Arguments.Length - 1];
for(var i = 1; i < m.Arguments.Length; i++)
msg[i - 1] = m.Arguments[i];
var temp = await Message(user.ID,
$@"Hoi!
Je hebt onlangs contact gezocht met de auteur van de bot.
Je hebt onderstaande reactie ontvangen van {m.From}:
{string.Join(" ", msg)}").HandleReply(bot);
return Message(m, $"Het bericht is verzonden naar {user}");
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
if (InvocatedByMessageFlow)
{
var bericht = m.Text;
var userNameDisplay = m.From.Username != null ? $" (@{m.From.Username})" : string.Empty;
foreach (User u in bot.Admins)
{
await Message(u.ID,
$@"Beste {u},
Er is een contact verzoek ontvangen van {m.From}{userNameDisplay}.
Het bericht is als volgt:
{m.Text}").HandleReply(bot);
}
}
return Message(m.From.ID, "Je bericht is verzonden!");
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
if (IsInGame(m.From))
return Message(m, "You're allready in a game");
bool gameAvailable = false;
var games = GetGames();
foreach(Game game in games)
if (!game.Playing)
{
gameAvailable = true;
break;
}
if (gameAvailable)
{
var flow = new JoinMessageFlow(GetGames());
m.From.MessageFlow = new MessageFlow(m.From, new FlowObject { Handler = flow });
return flow.UserMessage(m);
}
else
return Message(m, "There are currently no games available");
}
protected async override Task<TelegramBotReply> HandleMessageAsync(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
int id;
if (!int.TryParse(m.Text.Substring(0, m.Text.IndexOf(')')), out id) || id >= games.Length)
{
MessageFlow.Failed();
return Message(m, "Invalid reply, please use the keyboard!", replyMarkup: keyboard);
}
else
{
int joinResponse = JoinGame(games[id].Host, m.From);
if(joinResponse != JOIN_SUCCESS)
{
string msg = null;
switch (joinResponse)
{
case JOIN_ALLREADYJOINED:
msg = "You allready joined this game!"; break;
case JOIN_HOSTNOTFOUND:
msg = "Host not found"; break;
case JOIN_JOINISHOST:
msg = "You are allready hosting a game"; break;
case JOIN_PARTYFULL:
msg = "This party is full"; break;
}
return Message(m, msg ?? "Unknown error at joining the game");
}
}
var joinMsg = Message(-1, $"{m.From} has joined the game");
foreach(var player in games[id].Players)
{
if(player != m.From)
{
joinMsg.ChatId = player.ID;
await joinMsg.HandleReply(bot);
}
}
return Message(m, $"Successfuly joined the game from: {games[id].Host}", replyMarkup: JoinMessageHandler.JoinedPlayerKeyboard);
}
public async Task<TelegramBotReply> DoNext(TelegramBot bot, Message m, MessageHandlerType type)
{
if (!HasNext)
return null;
else
{
CurrentObject = _flow[Position++];
if (!CurrentObject.RequiresSlash && m.Text != null)
m.Arguments = m.Text.Split(' ');
_cancelled = false;
_canCancel = true;
CurrentObject.Handler.MessageFlow = this;
TelegramBotReply reply = await CurrentObject.Handler.HandleMessages(bot, m, type);
_canCancel = false;
if (_cancelled)
{
if (CurrentObject.HasFailedMessage)
{
CurrentObject.FailedMessage.ChatId = m.Chat.ID;
return CurrentObject.FailedMessage;
}
else
return reply;
}
else
{
CurrentObject.Handler.MessageFlow = null;
if (!HasNext && _user.MessageFlow == this)
_user.MessageFlow = null;
if (reply == null || CurrentObject.ReturnDefaultMessage)
return reply;
else
{
CurrentObject.CustomMessage.ChatId = m.Chat.ID;
return CurrentObject.CustomMessage;
}
}
}
}
public void RegisterHandler <T>(MessageHandlerType handlerType, Action <T> messageHandler, bool catchAndSendExceptions)
{
if (catchAndSendExceptions)
{
messageHandler = this.WrapActionWithErrorHandling(messageHandler);
}
if (!this.handlers.ContainsKey(typeof(T)))
{
this.handlers.Add(typeof(T), new List <object>());
}
IList <object> handlersForType = this.handlers[typeof(T)];
var handler = new MessageHandler <T>
{
Type = handlerType,
Handler = messageHandler,
};
handlersForType.Add(handler);
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
return Message(m,
@"/rooster - Haalt het rooster van vandaag op. In weekenden van de hieropvolgende komende week
/vandaag - Haalt het rooster van vandaag op
/morgen - Haalt het rooster van morgen op
/volgendeweek - Haalt het rooster van de volgende week op. In weekenden haalt hij het rooster voor over 2 weken op
/nu - Haalt de huidige en eerstvolgende les op
/klas - Pas de klas aan waaraan je gekoppeld bent
/docent - Pas de docent aan waaraan je gekoppeld bent
/klasrooster - Haal het rooster op voor een klas waar je niet aan gekoppeld bent
/docentrooster - Haal het rooster op van een docent waar je niet aan gekoppeld bent
/instellingen - Pas gebruikersinstellingen aan
/afmelden - Meld je af voor de bot
/annuleer - Annuleer de huidige operatie.
/contact - Toon contactgegevens
/nieuwbericht - Maak een nieuw bericht voor de auteur van deze bot
/help - Toont hulp voor de bot
Op zaterdagen en zondagen wordt het rooster voor de aankomende week getoond.
Het /volgendeweek commando laat dan van de hieropvolgende week het rooster zien.");
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
var roosterFor = PreferenceRegistry.GetRoosterForUser(m.From);
if (roosterFor == null)
{
m.From.MessageFlow = new MessageFlow(m.From, new FlowObject
{
Handler = _responseHandler,
RequiresSlash = false,
FailedMessage = _failedMessage
});
return Message(m,
@"Welkom bij de Windesheim Rooster bot!
Je hebt bijna toegang tot de makkelijkste manier om je Windesheim rooster te checken!
Nu moet je alleen nog even je klas of docentcode invullen:"
, replyMarkup: ForceReply.Instance);
}
else
return Message(m,
$@"Leuk dat je weer terug bent bij de bot!
Je hebt eerder gebruik gemaakt van de bot, en je staat geregistreerd voor: {roosterFor}.
Als je dit wilt veranderen kun je '/klas' typen."
);
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
switch(m.Command)
{
case "/nieuwbericht":
m.From.MessageFlow = new MessageFlow(m.From, sendMessage);
return Message(m, "Vul hieronder je bericht in.\n\rTik op /annuleer om het versturen van het bericht te annuleren." + (m.From.Username == null ? "\n\rLet op! Zonder telegram gebruikersnaam kan er geen contact met jou opgenomen worden!" : string.Empty), replyMarkup: ForceReply.Instance);
default:
return Message(
m,
@"Deze bot is gemaakt door Sander van 't Einde, derdejaars student Software Engineering.
Druk hieronder op '/nieuwbericht' om een bericht te versturen naar Sander.
Bij het bericht wordt je naam op Telegram en eventuele gebruikersnaam meegestuurd.
Interesse in de werking van de bot? De code is in te zien op https://github.com/sandervanteinde/TelegramBot
Donaties voor deze gratis service zijn uiteraard welkom op: https://www.PayPal.me/sander3991
© Sander van 't Einde 2015-2016",
replyMarkup: _keyboard,
disableWebPagePreview: true
);
}
}
internal async override Task<TelegramBotReply> HandleMessages(TelegramBot bot, Message m, MessageHandlerType type) => await HandleMessageAsync(bot, m, type);
protected abstract Task<TelegramBotReply> HandleMessageAsync(TelegramBot bot, Message m, MessageHandlerType type);
protected sealed override TelegramBotReply HandleMessage(TelegramBot bot, Message m, MessageHandlerType type)
{
throw new Exception("You can't call the HandleMessage function in the TemplateMessageHandlerAsync class. User HandleMessageAsync instead!");
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
var bitmap = new Bitmap(100, 100);
for (var i = 0; i < 100; i++)
bitmap.SetPixel(i, i, Color.Red);
var stream = new MemoryStream();
bitmap.Save("test.png", System.Drawing.Imaging.ImageFormat.Png);
bitmap.Save(stream, System.Drawing.Imaging.ImageFormat.Png);
return Photo(m, stream, "filename.png", "This is the file!");
}
protected override TelegramBotReply HandleMessage(TelegramBot.TelegramBot bot, Message m, MessageHandlerType type)
{
StringBuilder sb = new StringBuilder();
WindesheimRoosterConvertor.DumpCache(sb);
return Message(m, sb.ToString());
}
public InlineTypedMessageHandler(MessageHandlerType <T> handler)
{
_handler = handler;
}
/// <summary>
/// 构造
/// </summary>
/// <param name="messageId"></param>
/// <param name="type"></param>
public MessageHandlerAttribute(string messageId, MessageHandlerType type)
{
MessageId = messageId;
Type = type;
}
/// <summary>
/// Automatically created <see cref="MessageHandlerType{T}"/> and registers it as message handler.
/// </summary>
/// <seealso cref="Register(Asteroids.Core.Messaging.IMessageHandler)"/>
public World Register <T>(MessageHandlerType <T> handle) where T : Message
{
_messageHandlers.Add(new InlineTypedMessageHandler <T>(handle));
return(this);
}
static extern void gimp_message_set_handler(MessageHandlerType handler);
static extern void gimp_message_set_handler(MessageHandlerType handler);
