private void HelpSubscription(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 2)
{
theMessage.Answer("Die Funktion benötigt 2 Parameter: !subscribe help <SubscriptionProvider>");
return;
}
SubscriptionProvider provider = PluginManager.Plugins.SingleOrDefault(x => x.Names.Contains(theMessage.CommandArgs[1], StringComparer.OrdinalIgnoreCase)).As <SubscriptionProvider>();
if (provider == null)
{
theMessage.Answer("Es gibt keinen solchen SubscriptionProvider");
return;
}
HelpAttribute help = provider.GetType().GetCustomAttribute <HelpAttribute>();
if (help != null)
{
theMessage.Answer(help.Help);
}
else
{
theMessage.Answer("Der Subscription Provider bietet keine Hilfe an");
}
}
private void Config(IrcMessage theMessage)
{
if (!theMessage.CommandArgs.Count.In(2, 3))
{
theMessage.Answer("Syntax: !admin config <key> <value>");
return;
}
string key = theMessage.CommandArgs[1];
if (theMessage.CommandArgs.Count == 2)
{
if (ConfigHelper.KeyExists(key))
{
theMessage.Answer(ConfigHelper.GetString(key));
}
else
{
theMessage.Answer($"Der Schlüssel {key} existiert nicht");
}
}
else if (theMessage.CommandArgs.Count == 3)
{
if (key == "remove")
{
ConfigHelper.Remove(theMessage.CommandArgs[2]);
theMessage.Answer("Wert gelöscht");
}
else
{
ConfigHelper.SetValue(key, theMessage.CommandArgs[2]);
theMessage.Answer("Wert geändert");
}
}
}
public void Run(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count > 1)
{
using (var context = new BotContext())
{
if (theMessage.ServerConnetion.IrcClient.IsMe(theMessage.CommandArgs[0]))
{
theMessage.Answer("Wieso sollte ich mich selbst an etwas erinnern ;) ?");
return;
}
User u = context.GetUser(theMessage.CommandArgs[0]);
if (u != null)
{
ReminderEntry r = new ReminderEntry();
r.Created = DateTime.Now;
r.Creator = context.GetUser(theMessage.Nickname);
r.Message = theMessage.CommandArgs.Skip(1).Join(" ");
r.User = u;
context.ReminderEntries.Add(r);
context.SaveChanges();
theMessage.Answer("Okay ich werde es sobald wie möglich zustellen");
}
else
{
theMessage.Answer("Den Benutzer habe ich aber noch nie gesehen");
}
}
}
else
{
theMessage.Answer("Die Eingabe war nicht korrekt: !remind <Benutzer> <Nachricht>");
}
}
public void Run(IrcMessage theMessage)
{
if (!theMessage.HasArgs)
{
IEnumerable <PluginInfo> plugins = PluginManager.Plugins.Where(x => !x.IsHidden && x.IsCommand && x.Names.Count > 0);
using (var context = new BotContext())
{
if (!Toolbox.IsOp(context.GetUser(theMessage.Nickname)))
{
plugins = plugins.Where(x => !x.AuthenticationRequired);
}
}
theMessage.Answer("Derzeit verfügbare Befehle: " + plugins.Select(x => x.Names[0]).OrderBy(x => x).Join(", "));
theMessage.Answer("Hilfe zu jedem Befehl mit \"!help befehl\"." + (theMessage.IsPrivate ? "" : "Um die anderen nicht zu belästigen kannst du mich auch per PM (query) anfragen"));
}
else
{
PluginInfo info = PluginManager.Get(theMessage.CommandArgs[0]);
if (info != null && !String.IsNullOrEmpty(info.HelpText))
{
theMessage.Answer(info.HelpText);
}
else
{
theMessage.Answer("Ich konnte keinen Befehl finden der so heißt");
}
}
}
public void Run(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 2)
{
theMessage.AnswerHelp(this);
return;
}
PluginInfo bgtask = PluginManager.Get(theMessage.CommandArgs[0]);
if (bgtask?.IsBackgroundTask ?? false)
{
if (theMessage.CommandArgs[1].Equals("start", StringComparison.OrdinalIgnoreCase))
{
bgtask.Start();
theMessage.Answer("Task erfolgreich gestartet");
}
else if (theMessage.CommandArgs[1].Equals("stop", StringComparison.OrdinalIgnoreCase))
{
bgtask.Stop();
theMessage.Answer("Task erfolgreich angehalten");
}
else
{
theMessage.Answer("Ich habe die Aktion die auf den Task angewandt werden soll nicht verstanden");
}
}
else
{
theMessage.Answer($"Ich habe keinen Task namens {theMessage.CommandArgs[0]} finden können");
}
}
private static void BoxDbAdd(IrcMessage theMessage)
{
Match match = Regex.Match(theMessage.CommandLine, "boxdb add \"(?<short>[^\"]*)\" \"(?<full>[^\"]*)\" (?<regex>.*)");
if (!match.Success)
{
theMessage.Answer("Zu wenig Parameter: boxdb add \"(?<short>[^\"]*)\" \"(?<full>[^\"]*)\" (?<regex>.*)");
return;
}
Box box = BoxDatabase.GetBoxByShortName(match.Groups["short"].Value);
string[] regexes = Regex.Matches(match.Groups["regex"].Value, "\"(?<value>[^\"]*)\"").Cast <Match>().Select(x => x.Groups["value"].Value).ToArray();
if (box == null)
{
box = BoxDatabase.AddBox(match.Groups["short"].Value, match.Groups["full"].Value, regexes);
theMessage.Answer("Box erfolgreich hinzugefügt");
}
else
{
box.FullName = match.Groups["full"].Value;
box.AddRegex(regexes);
theMessage.Answer("Box Infos geupdated");
}
}
public void Run(IrcMessage theMessage)
{
using (var context = new BotContext())
{
User user = context.GetUser(theMessage.Nickname);
if (user.Authenticated)
{
theMessage.Answer("Du bist bereits authentifiziert");
return;
}
if (!theMessage.IsPrivate)
{
theMessage.Answer("Ohje das solltest du besser im Query tuen");
return;
}
if (user.CheckPassword(theMessage.CommandLine))
{
user.Authentication = DateTime.Now;
context.SaveChanges();
theMessage.SendPrivateMessage("Du bist jetzt authentifiziert");
}
else
{
theMessage.SendPrivateMessage("Das Passwort war falsch");
}
theMessage.Hidden = true;
}
}
public void Run(IrcMessage theMessage)
{
switch (theMessage.CommandArgs[0])
{
case "box-recheck":
using (var context = new BotContext())
{
throw new NotImplementedException();
//db.Query<BoxEntry>().ForEach(x => { x.ReAssociateBoxes(); db.SaveOrUpdate(x); });
}
theMessage.Answer("Done");
return;
case "boxdb":
BoxDB(theMessage);
return;
case "config":
Config(theMessage);
return;
default:
theMessage.Answer("Das habe ich nicht verstanden: Unterbefehle: box-recheck, boxdb (add, remove, regex, list), config");
return;
}
}
public void Run(IrcMessage theMessage)
{
List <Labordaten> daten = LaborDaten.GetItem(true);
if (LaborDaten.Renewed == DateTime.MinValue)
{
theMessage.Answer("Ich konnte leider keine Daten von der Laborwebseite abrufen und mein Cache ist leer");
return;
}
if (!LaborDaten.IsUpToDate)
{
theMessage.Answer("Es war mir nicht möglich den Labor Cache zu erneuern. Grund: " + LaborDaten.LastUpdateFail?.Message + ". Verwende Cache vom " + LaborDaten.Renewed.ToString());
}
if (String.IsNullOrEmpty(theMessage.CommandLine))
{
theMessage.Answer("Aktuelle Labor Daten: " + daten.Select(x => $"{x.Typ}: {x.Datum}").Join(", ") + " - Zum Labor: " + Toolbox.ShortUrl("http://www.avm.de/de/Service/Service-Portale/Labor/index.php"));
}
else
{
string BoxName = BoxDatabase.GetShortName(theMessage.CommandLine);
if (daten.FirstOrDefault(x => x.Typ == BoxName) is { } first)
{
theMessage.Answer($"Die neueste {first.Typ} labor Version ist am {first.Datum} erschienen mit der Versionsnummer: {first.Version} - Laborseite: {first.Url}");
}
public void Run(IrcMessage theMessage)
{
if (String.Equals(theMessage.CommandLine, theMessage.ServerConnetion.IrcClient.Nickname, StringComparison.OrdinalIgnoreCase))
{
theMessage.Answer("Ich bin gerade hier und laut meinem Logik System solltest du auch sehen können was ich schreibe");
return;
}
using (var context = new BotContext())
{
SeenEntry entry = context.SeenEntries.FirstOrDefault(x => x.User == context.Nicknames.FirstOrDefault(n => n.Name == theMessage.CommandLine).User);
string output = "";
if (entry != null)
{
if (entry.LastSeen.HasValue)
{
output = "Den/Die habe ich hier zuletzt am " + entry.LastSeen.Value.ToString("dd.MM.yyyy ") + "um" + entry.LastSeen.Value.ToString(" HH:mm:ss ") + "Uhr gesehen.";
}
if (entry.LastMessaged.HasValue)
{
output += " Am " + entry.LastMessaged.Value.ToString("dd.MM.yyyy ") + "um" + entry.LastMessaged.Value.ToString(" HH:mm:ss ") + "Uhr sagte er/sie zuletzt: \"" + entry.LastMessage + "\".";
}
else
{
output += " Den habe ich hier noch nie etwas schreiben sehen.";
}
}
theMessage.Answer(!String.IsNullOrEmpty(output) ? output.Trim() : "Scheinbar sind meine Datensätze unvollständig, tut mir leid");
}
}
private void RemoveSubscription(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 3)
{
theMessage.Answer("Die Funktion benötigt 3 Parameter: !subscribe remove <PluginName> <SubscriptionProvider>");
return;
}
PluginInfo plugin = PluginManager.Plugins.SingleOrDefault(x => x.IsNamed(theMessage.CommandArgs[1]));
if (plugin == null)
{
theMessage.Answer("Ein solches Plugin konnte ich nicht ausfindig machen");
return;
}
SubscriptionProvider provider = PluginManager.Plugins.SingleOrDefault(x => x.IsNamed(theMessage.CommandArgs[2])).As <SubscriptionProvider>();
if (provider == null)
{
theMessage.Answer("Es gibt keinen solchen SubscriptionProvider");
return;
}
using (var context = new BotContext())
{
Subscription sub = context.Subscriptions.FirstOrDefault(x => x.User == context.GetUser(theMessage.Nickname) && x.Provider == provider.PluginID && x.Plugin == plugin.ID);
if (sub != null)
{
context.Subscriptions.Remove(sub);
theMessage.Answer("Subscription entfernt");
}
else
{
theMessage.Answer("Ich konnte keine Zutreffende Subscription finden die ich hätte entfernen können");
}
}
}
public void Run(IrcMessage theMessage)
{
string target = theMessage.CommandArgs.First().ToLower();
string word = theMessage.CommandArgs.Skip(1).Join(" ");
if (target.Length != 2)
{
target = "en";
word = theMessage.CommandArgs.Join(" ");
}
Translation translation = GoogleTranslator.GetTranslation(word, target, "");
if (String.IsNullOrEmpty(translation?.FullTranslation))
{
theMessage.Answer("Das hat nicht so geklappt wie erwartet");
return;
}
if (translation.dict != null && theMessage.CommandArgs.Count(x => x != "en") == 1)
{
StringBuilder sb = new StringBuilder(translation.FullTranslation);
foreach (Dic item in translation.dict)
{
sb.AppendFormat(" - {0}: {1}", item.pos, item.terms.Take(5).Join(", "));
}
theMessage.Answer(sb.ToString());
}
else if (!String.IsNullOrEmpty(translation.FullTranslation))
{
theMessage.Answer(translation.FullTranslation);
}
}
private static void SubscriptionsAvailable(IrcMessage theMessage)
{
string[] names = PluginManager.GetOfType <SubscriptionProvider>().Select(x => x.Names.FirstOrDefault()).Where(x => !String.IsNullOrEmpty(x)).ToArray();
theMessage.Answer("Es sind folgende SubscriptionProvider verfügbar: " + names.Join(", "));
string[] plugins = PluginManager.Plugins.Where(x => x.IsSubscribeable).Select(x => x.Names.FirstOrDefault()).Where(x => !String.IsNullOrEmpty(x)).ToArray();
theMessage.Answer("Folgende Plugins werden unterstützt: " + plugins.Join(", "));
}
public void Run(IrcMessage theMessage)
{
string channel;
if (theMessage.CommandArgs.Count < 2 | !Int32.TryParse(theMessage.CommandArgs.FirstOrDefault(), out int tage))
{
if (theMessage.IsPrivate)
{
theMessage.Answer("Da du mir Privat schreibst, kann ich den Channel nicht erraten. Verwende: !bots <Tage> <Channel>");
return;
}
channel = theMessage.Source;
}
else if (theMessage.CommandArgs.Count == 2)
{
channel = theMessage.CommandArgs[1];
}
else
{
theMessage.AnswerHelp(this);
return;
}
if (!theMessage.Data.Irc.JoinedChannels.Contains(channel))
{
theMessage.Answer("In diesem Channel befinde ich mich nicht und kann daher keine Auskunft geben.");
return;
}
using (var context = new BotContext())
{
var UserImChannel = theMessage.Data.Irc.GetChannel(channel).Users.Values.Select(x =>
{
User u = context.GetUser(x.Nick);
SeenEntry entry = context.SeenEntries.FirstOrDefault(s => s.User.Id == u.Id);
return(new { Nickname = x.Nick, User = u, SeenEntry = entry });
}).ToList();
string wahrscheinlichInaktiv = UserImChannel.Where(x => x.User == null || x.SeenEntry == null).Select(x => x.Nickname).Join(", ");
string bestimmtInaktiv = UserImChannel.Where(x => x.SeenEntry != null && x.SeenEntry.LastMessaged < DateTime.Now.AddDays(-tage)).Select(x => x.Nickname).Join(", ");
if (!String.IsNullOrWhiteSpace(wahrscheinlichInaktiv))
{
theMessage.Answer($"User die wahrscheinlich inaktiv sind: {wahrscheinlichInaktiv}");
}
if (!String.IsNullOrWhiteSpace(bestimmtInaktiv))
{
theMessage.Answer($"User die definitiv länger als {tage} Tage inaktiv sind: {bestimmtInaktiv}");
}
if (String.IsNullOrWhiteSpace(wahrscheinlichInaktiv) && String.IsNullOrWhiteSpace(bestimmtInaktiv))
{
theMessage.Answer("Keinen Benutzer gefunden der in diese Kriterien fällt");
}
}
}
private static void BoxDbList(IrcMessage theMessage)
{
string[] allBoxes = BoxDatabase.Boxen.Select(x => x.ShortName).OrderByDescending(x => x).ToArray();
if (allBoxes.Length == 0)
{
theMessage.Answer("Oh... ich habe keine Einträge über Boxen");
return;
}
theMessage.Answer($"Ich kenne folgende Boxen: {allBoxes.Join(", ")}");
}
private static void BoxDbInfo(IrcMessage theMessage)
{
Box box = BoxDatabase.GetBoxByShortName(theMessage.CommandArgs[2]);
if (box == null)
{
theMessage.Answer("So eine Box habe ich nicht gefunden");
return;
}
theMessage.Answer($"ShortName: {box.ShortName}, FullName: {box.FullName}, RegexPatterns: {box.RegexPattern.Select(x => x.Pattern).Join(", ")}");
}
public void Run(IrcMessage theMessage)
{
try
{
DateTime now = DateTime.Now;
theMessage.Answer("Laut meiner Uhr ist es gerade " + now.ToString("HH:mm:ss") + " am " + now.ToShortDateString() + " in der Kalenderwoche " + GetKalenderwoche(now));
}
catch
{
theMessage.Answer("Scheinbar ist meine Uhr kaputt, statt der Zeit habe ich nur eine Exception bekommen :(");
}
}
public void Run(IrcMessage theMessage)
{
try
{
Expression exp = new Expression(theMessage.CommandLine);
object result = exp.Evaluate();
theMessage.Answer($"{exp.ParsedExpression} ergibt {result}");
}
catch (Exception ex)
{
theMessage.Answer("Die Eingabe ist ungültig oder konnte nicht interpretiert werden: " + ex.Message);
}
}
public void Server_OnPostProcessingMessage(object sender, IrcMessage theMessage)
{
if (theMessage.Message.Contains("#96*6*") && !theMessage.IsIgnored)
{
if (DateTime.Now.Hour > 5 && DateTime.Now.Hour < 16)
{
theMessage.Answer("Kein Bier vor 4");
}
else
{
theMessage.Answer("Bier holen");
}
}
}
public void Run(IrcMessage theMessage)
{
using (var context = new BotContext())
{
BoxManager manager = new BoxManager(context.GetUser(theMessage.Nickname), context);
if (manager.HasBox(theMessage.CommandLine))
{
theMessage.Answer($"Wups, danke aber du hast mir deine \"{theMessage.CommandLine}\" bereits mitgeteilt ;-).");
return;
}
BoxEntry box = manager.AddBox(theMessage.CommandLine);
theMessage.Answer($"Okay danke, ich werde mir deine \"{box.Text}\"{(box.Box != null ? " (" + box.Box.FullName + ")" : "")} notieren.");
}
}
public void Run(IrcMessage theMessage)
{
using (var context = new BotContext())
{
if (context.TryGetUser(theMessage.CommandLine) is { } u)
{
u.Admin = true;
context.SaveChanges();
theMessage.Answer("Okay");
return;
}
theMessage.Answer("Den Benutzer kenne ich nicht");
}
}
public void Run(IrcMessage theMessage)
{
using (var context = new BotContext())
{
BoxManager mgr = new BoxManager(context.GetUser(theMessage.Nickname), context);
if (mgr.RemoveBox(theMessage.CommandLine))
{
theMessage.Answer("Erledigt!");
}
else
{
theMessage.Answer("Der Suchstring wurde nicht gefunden und deshalb nicht gelöscht");
}
}
}
public void Run(IrcMessage theMessage)
{
using (var context = new BotContext())
{
string nickname = theMessage.CommandArgs.FirstOrDefault();
if (context.TryGetUser(nickname) is { } u)
{
u.Ignored = false;
context.SaveChanges();
theMessage.Answer($"Ignoranz für {nickname} aufgehoben");
return;
}
theMessage.Answer("Oh... Dieser User ist mir nicht bekannt");
}
}
public void Run(IrcMessage theMessage)
{
try
{
IDocument document = BrowsingContext.New(Configuration.Default.WithDefaultLoader()).OpenAsync("http://freetz.org/changeset").Result;
string changeset = document.QuerySelector("#title").TextContent.Trim().Split(' ')[1];
string datum = Regex.Replace(document.QuerySelector("#overview dd.time").TextContent.Trim().Replace("\n", ""), "[ ]{2,}", " ");
theMessage.Answer($"Der aktuellste Changeset ist {changeset} und wurde am {datum} in den Trunk eingecheckt. Siehe: http://freetz.org/changeset");
}
catch (Exception ex)
{
theMessage.Answer("Das parsen oder Zugreifen auf die Freetz Webseite schlug fehl. Möglicherweise wurde die Struktur geändert oder es trat ein anderer Fehler auf.");
Log.Error(ex, "Zugriff auf die Freetz Webseite fehlgeschlagen");
}
}
public virtual void ParseSubscriptionSetup(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 3)
{
theMessage.Answer("Zu wenig Parameter, probier mal: !subscribe setup <SubscriptionProvider> <Einstellung>");
return;
}
using (var context = new BotContext())
{
UserKeyValueEntry entry = context.GetStorageOrCreate(theMessage.Nickname, PluginId);
entry.Value = theMessage.CommandArgs[2];
context.SaveChanges();
}
theMessage.Answer("Einstellungen erfolgreich gespeichert");
}
public void Run(IrcMessage theMessage)
{
using (var context = new BotContext())
{
User u = context.GetUser(theMessage.CommandLine);
if (u == null)
{
theMessage.Answer("Den Benutzer kenne ich nicht");
return;
}
u.Admin = true;
context.SaveChanges();
theMessage.Answer("Okay");
}
}
public virtual void AddSubscription(IrcMessage theMessage, PluginBase plugin)
{
Contract.Requires(theMessage != null && plugin != null);
using (var context = new BotContext())
{
User u = context.GetUser(theMessage.Nickname);
Subscription SpecificSubscription = context.Subscriptions.Include(x => x.Bedingungen).FirstOrDefault(x => x.User.Id == u.Id && x.Provider == PluginID && x.Plugin == plugin.PluginID);
if (SpecificSubscription == null)
{
SpecificSubscription = new Subscription()
{
Plugin = plugin.PluginID,
Provider = PluginID,
User = u,
Bedingungen = new List <SubscriptionBedingung>()
};
if (theMessage.CommandArgs.Count > 3 && !String.IsNullOrEmpty(theMessage.CommandArgs[3]))
{
SpecificSubscription.Bedingungen.Add(new SubscriptionBedingung {
Bedingung = theMessage.CommandArgs[3]
});
}
context.Subscriptions.Add(SpecificSubscription);
theMessage.Answer($"Du wirst absofort mit {GetType().GetCustomAttribute<NameAttribute>().Names[0]} für {plugin.GetType().GetCustomAttribute<NameAttribute>().Names[0]} benachrichtigt");
}
else if (theMessage.CommandArgs.Count > 3 && !String.IsNullOrEmpty(theMessage.CommandArgs[3]) && SpecificSubscription.Bedingungen.Count == 0)
{
SpecificSubscription.Bedingungen.Add(new SubscriptionBedingung {
Bedingung = theMessage.CommandArgs[3]
});
SpecificSubscription.Bedingungen = SpecificSubscription.Bedingungen.Distinct(x => x.Bedingung).OrderBy(x => x.Bedingung).ToList();
theMessage.Answer("Bedingung für Subscription hinzugefügt");
}
else if (SpecificSubscription.Bedingungen.Count > 0)
{
SpecificSubscription.Bedingungen.Clear();
theMessage.Answer("Bedingungen entfernt");
}
else
{
theMessage.Answer("Du bist bereits für dieses Plugin eingetragen");
}
context.SaveChanges();
}
}
public void Run(IrcMessage theMessage)
{
switch (theMessage.CommandArgs.FirstOrDefault())
{
case "add":
SubscriptionAdd(theMessage);
return;
case "available":
SubscriptionsAvailable(theMessage);
return;
case "list":
SubscriptionsList(theMessage);
return;
case "setup":
SetupSubscription(theMessage);
return;
case "remove":
RemoveSubscription(theMessage);
return;
case "help":
HelpSubscription(theMessage);
return;
default:
theMessage.Answer("Das kommt mir nicht bekannt vor...");
theMessage.AnswerHelp(this);
return;
}
}
public override void ParseSubscriptionSetup(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 3)
{
theMessage.Answer("Zu wenig Parameter, probier mal: !subscribe setup <SubscriptionProvider> <Einstellung>");
return;
}
if (theMessage.CommandArgs[2] == "NOTICE" || theMessage.CommandArgs[2] == "PRIVMSG")
{
base.ParseSubscriptionSetup(theMessage);
}
else
{
theMessage.Answer("Ungültige Option, mögliche Optionen sind NOTICE oder PRIVMSG");
}
}
private static void BoxDB(IrcMessage theMessage)
{
if (theMessage.CommandArgs.Count < 2)
{
theMessage.Answer("Zu wenig Parameter: add, remove, regex, list");
return;
}
switch (theMessage.CommandArgs[1])
{
case "add":
BoxDbAdd(theMessage);
return;
case "remove":
BoxDbRemove(theMessage);
return;
case "regex":
BoxDbRegex(theMessage);
return;
case "list":
BoxDbList(theMessage);
return;
case "info":
BoxDbInfo(theMessage);
return;
}
}
