public void ExecuteMethodFromRegex(IrcEventArgs e)
{
if(isRunning==true)
{
SendUnscramble(e);
}
foreach(KeyValuePair<string,string> pair in regexDictionary)
{
regex = new Regex(pair.Key);
if(regex.IsMatch(e.Data.Message))
{
string methodName = pair.Value;
//Get the method information using the method info class
MethodInfo mi = this.GetType().GetMethod(methodName);
object[] objargs = new object[1];
objargs[0]=e;
// //Invoke the method
// // (null- no paramyeseter for the method call
// // or you can pass the array of parameters...)
if(mi==null)
{
//client.SendMessage(SendType.Message, e.Data.Channel,"mi is null! "+e.Data.Message);
SharpBotClient.SharpBotClient.SendChannelMessag(e.Data.Channel,"handled from client");
}
else
{
mi.Invoke(this,objargs);
}
}
}
}
private void _ircClient_OnQueryNotice(object sender, SIRC4N.IrcEventArgs e)
{
if (_authenticate && NoticeIsExpectedServicesAgentMessage(e.Data.Nick, e.Data.Message))
{
JoinChannelsForNetwork();
}
}
void client_OnQueryMessage(object sender, IrcEventArgs e)
{
string message = e.Data.Message;
string nick = e.Data.Nick;
if (!globalStorage.IgnoredUsers.Contains(nick) && message.StartsWith(activator))
{
if (message.Equals(activator))
{
log.VerboseMessage(nick + " sent karma activator, sending back how to write a request properly");
client.SendMessage(SendType.Message, nick, "Usage: " + activator + " [subject]");
}
else
{
string karmaOf = message.Substring(activator.Length + 1); // this is the length plus a space
log.VerboseMessage(nick + " asked for karma of " + karmaOf);
if (globalStorage.karmaDatabase.ContainsKey(karmaOf))
{
int karma = globalStorage.karmaDatabase[karmaOf];
client.SendMessage(SendType.Message, nick, karmaOf + " has a karma of " + karma);
log.DebugMessage("karma is " + karma);
}
else
{
client.SendMessage(SendType.Message, nick, karmaOf + " has karma of 0.");
log.DebugMessage("karma is 0");
}
}
}
}
protected Match GetMatch(MessageType type, IrcEventArgs args)
{
string msg = args.Data.Message;
if (!msg.StartsWith(Prefix)) {
return null;
}
msg = msg.Substring(Prefix.Length);
var match = Attribute.Regex.Match(msg);
if (Attribute.Type != MessageType.All && Attribute.Type != type) {
return null;
}
if (!args.Data.Message.StartsWith(Prefix)) {
return null;
}
if (!match.Success) {
return null;
}
return match;
}
void OnQueryMessage(object sender, IrcEventArgs e)
{
Dispatcher.BeginInvoke(new Action(() =>
{
lblMessage.Content = string.Format("{0}:\n(private) <{1}> {2}", e.Data.Type, e.Data.Nick, @e.Data.Message);
}));
}
void Client_OnQueryMessage(object sender, IrcEventArgs e)
{
using (var context = new DataContext())
{
switch (e.Data.Type)
{
case ReceiveType.Join:
Client.RfcNotice(e.Data.Nick, "Hi, I am a IRC bot written in C# that executes code with Roslyn.");
Client.RfcNotice(e.Data.Nick, "To try me out, send me a private message with the following: var hello = \"hello world\"; return hello;");
Client.RfcNotice(e.Data.Nick, "You can also execute multi-line commands by starting the line with \">>\" remember to have a return statement in your last command");
break;
case ReceiveType.ChannelMessage:
if ((e.Data.Type == ReceiveType.ChannelMessage && e.Data.Message.StartsWith(BotSettings.Default.Name) && e.Data.Message.Length > BotSettings.Default.Name.Length) || (e.Data.Message.StartsWith(">>") && e.Data.Message.Length > 4))
{
var queryCommand = e.Data.Message.Substring(string.Format(BotSettings.Default.Name).Length + 1).Trim();
ProcessCommand(e, context, queryCommand);
}
break;
case ReceiveType.QueryMessage:
var channelCommand = e.Data.Message;
ProcessCommand(e, context, channelCommand);
break;
}
}
}
void OnChannelMessage(object sender, IrcEventArgs e)
{
Dispatcher.BeginInvoke(new Action(() =>
{
lblMessage.Content = string.Format("{0}:\n({1}) <{2}> {3}", e.Data.Type, e.Data.Channel, e.Data.Nick, @e.Data.Message);
}));
}
protected override CommandCompletedEventArgs Worker(IrcEventArgs e)
{
Thread.Sleep(3000);
e.Data.Irc.SendMessage(SendType.Message, e.Data.Channel, "Async wait done");
return null;
}
protected override CommandCompletedEventArgs Worker(IrcEventArgs e)
{
string url = "http://tyda.se/search?form=1&w=" + e.Data.Message.Split(new char[] { ' ' }, 2).LastOrDefault(); // TODO: URL encode
string html = HtmlHelper.GetFromUrl(url);
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(html);
HtmlNodeCollection foundNodes = doc.DocumentNode.SelectNodes("//div [@class = 'tyda_content']/descendant::table [@class = 'tyda_res_body']/descendant::table [starts-with(@class, 'tyda_res_body_trans')]/descendant::a [starts-with(@id, 'tyda_trans')]");
string message;
if (foundNodes != null && foundNodes.Count > 0)
{
StringBuilder sb = new StringBuilder();
sb.Append("Translate: ");
IEnumerable<HtmlNode> nodes = foundNodes.Take(4);
foreach (HtmlNode node in nodes)
{
if (!string.IsNullOrWhiteSpace(node.InnerText))
{
sb.Append(node.InnerText);
if (node != nodes.Last())
sb.Append(", ");
}
}
message = sb.ToString();
}
else
message = "No results found";
return new CommandCompletedEventArgs(e.Data.Channel, new List<string> { message });
}
public override void Execute(IrcEventArgs args)
{
string destination = string.Empty;
ChannelList channelList = new ChannelList();
AddChannelsFromMessage(args.Data.MessageArray, channelList);
if(args.Data.Type == ReceiveType.QueryMessage)
{
if (channelList.Count == 0)
{
var channels = TaskListPlugin.Repository.GetChannels();
channelList.AddRange(channels);
}
destination = args.Data.Nick;
} else if(args.Data.Type == ReceiveType.ChannelMessage)
{
var channel = args.Data.Channel;
if(channelList.Count == 0)
{
channelList.Add(channel);
}
destination = channel;
}
foreach (var channel in channelList)
{
ShowTaskListForChannel(channel, destination);
}
}
public override void Execute(IrcEventArgs args)
{
var message = args.Data.MessageArray;
var channel = args.Data.Channel;
var nick = args.Data.Nick;
List<QuestionSet> sets = new List<QuestionSet>();
if(message.Length > 2)
{
for(int i = 2;i < message.Length;i++)
{
int i1 = i;
QuestionSet questionSetToFind = TriviaPlugin.QuestionSets.Find(x => x.QuestionSetName.StartsWith(message[i1]));
if(questionSetToFind != null)
{
sets.Add(questionSetToFind);
}
}
}
if (!TriviaPlugin.Games.ContainsKey(channel))
{
TriviaPlugin.Games.Add(channel,
sets.Count > 0 ? new TriviaGame(TriviaPlugin, channel, sets) : new TriviaGame(TriviaPlugin, channel));
}
TriviaPlugin.Games[channel].StartGame(nick);
}
public override void Execute(IrcEventArgs args)
{
var channel = args.Data.Channel;
var user = args.Data.Nick;
string madeNewTaskList = string.Empty;
if(args.Data.MessageArray.Length < 3)
throw new Exception("Not enough parameters supplied for command.");
var taskListName = GetTaskListName(args.Data.MessageArray);
string taskText = string.Empty;
for(int i = 2;i < args.Data.MessageArray.Length; i++)
taskText += string.Format(" {0}", args.Data.MessageArray[i]);
TaskList list = TaskListPlugin.Repository.GetTaskList(taskListName);
if(list == null)
{
// todo interface out a concept for default status
list = TaskListPlugin.Repository.CreateNewTaskList(taskListName, user, channel,string.Empty);
madeNewTaskList = "new";
}
Task newTask = list.NewTask(taskText, user);
TaskListPlugin.SendMessage(string.Format("Added task to {0} TaskList {1} ({2} / {3} completed)",madeNewTaskList, list.TaskName, list.CompletedTasks(),list.Tasks.Count), channel);
}
public override void Execute(IrcEventArgs args)
{
List<QuestionSet> questionSets = new List<QuestionSet>();
var questionSetNodes = TriviaPlugin.PluginSettings.SelectNodes(QuestionSetXPath);
if(questionSetNodes == null)
throw new Exception("Could not find any question sets in Settings config");
foreach (XmlNode node in questionSetNodes)
{
string filePath = TriviaPlugin.Bot.FilePath + node.InnerText;
if (!string.IsNullOrEmpty(node.InnerText) && File.Exists(filePath))
{
string questonSetName;
if (node.Attributes[QuestionSetNameAttributeName] != null
&& !string.IsNullOrEmpty(node.Attributes[QuestionSetNameAttributeName].Value))
{
questonSetName = node.Attributes[QuestionSetNameAttributeName].Value;
}
else
{
questonSetName = node.InnerText;
}
QuestionSet set = new QuestionSet(filePath) { QuestionSetName = questonSetName };
questionSets.Add(set);
}
}
TriviaPlugin.QuestionSets = questionSets;
}
public override bool ShouldExecuteCommand(IrcEventArgs args)
{
var currentGame = TriviaPlugin.GetGameForChannel(args.Data.Channel);
return base.ShouldExecuteCommand(args)
&& currentGame != null && currentGame.CurrentState != GameState.Started;
}
public override void Execute(IrcEventArgs args)
{
string channel = args.Data.Channel;
if(args.Data.MessageArray.Length < 2)
throw new Exception("Not enough parameters supplied");
string taskListName = args.Data.MessageArray[1];
TaskList taskList = Plugin.Repository.GetTaskList(taskListName);
if(taskList == null)
throw new Exception(string.Format("Could not find Task List {0}",taskListName));
List<Task> completedTasks = new List<Task>();
foreach (Task task in taskList)
{
if(task.Complete)
{
completedTasks.Add(task);
continue;
}
Plugin.SendMessage(task, channel);
}
foreach(Task task in completedTasks)
{
Plugin.SendMessage(task,channel);
}
}
public override IEnumerable<string> Execute(IrcEventArgs e)
{
string args = "";
if (e.Data.MessageArray.Length > 1)
args = string.Join(" ", e.Data.MessageArray.Skip(1));
args = args.Replace("\'", "");
args = args.Replace(">", "");
args = args.Replace("<", "");
args = args.Replace("|", "");
try
{
var proc = new System.Diagnostics.Process();
proc.EnableRaisingEvents = false;
proc.StartInfo.FileName = @"python";
proc.StartInfo.Arguments = scriptPath + " \"" + args + "\"";
proc.StartInfo.RedirectStandardOutput = true;
proc.StartInfo.WorkingDirectory = Directory.GetCurrentDirectory();
proc.StartInfo.UseShellExecute = false;
proc.StartInfo.StandardOutputEncoding = Encoding.UTF8;
proc.Start();
string data = proc.StandardOutput.ReadToEnd();
proc.WaitForExit();
return new[] {data};
}
catch
{
}
return null;
}
public bool Parse(IrcConnection aConnection, IrcEventArgs aEvent)
{
string tMessage = Helper.RemoveSpecialIrcChars(aEvent.Data.Message);
Log.Debug("Parse() " + aEvent.Data.Nick + " " + tMessage);
return Parse(aConnection, tMessage, aEvent);
}
public override IEnumerable<string> Execute(IrcEventArgs e)
{
string url = "http://www.urbandictionary.com/define.php?term=" + e.Data.Message.Split(new char[] { ' ' }, 2).LastOrDefault(); // TODO: URL encode
string html = "";
try
{
html = HttpHelper.GetFromUrl(url);
}
catch
{
return new [] { "Error fetching result" };
}
HtmlDocument doc = new HtmlDocument();
doc.LoadHtml(html);
HtmlNode node = doc.DocumentNode.SelectSingleNode("//div [@id = 'entries']/div [@class = 'box'][1]/descendant::div [@class = 'definition']");
IList<string> lines = new List<string>();
if (node != null && !string.IsNullOrWhiteSpace(node.InnerText))
{
var definition = node.InnerHtml
.Replace("<br>", " ")
.Replace("<br/>", " ")
.Replace("</br>", "")
.Replace("\n", "")
.Trim();
lines.Add(("UrbanDictionary: " + WebUtility.HtmlDecode(definition)).FormatToIrc());
}
else
lines.Add("No results found");
return lines;
}
public override void Execute(IrcEventArgs args)
{
string nick = args.Data.Nick;
string fullName = args.Data.From;
if (args.Data.MessageArray.Length == 1)
{
PrintCommands(Bot.Commands, nick);
if (Bot.AdminUserRepository.IsAdminUser(fullName))
PrintCommands(Bot.AdminCommands, nick);
return;
}
if (args.Data.MessageArray.Length == 2)
{
if (!Bot.PluginManager.Plugins.Any(x => string.Equals(x.Name, args.Data.MessageArray[1], StringComparison.CurrentCultureIgnoreCase)))
throw new Exception(string.Format("Could not find the plugin with the name '{0}'",args.Data.MessageArray[1]));
BotPlugin plugin = Bot.PluginManager.Plugins.Find(x => string.Equals(x.Name, args.Data.MessageArray[1]));
PrintCommands(plugin.Commands, nick);
if (Bot.AdminUserRepository.IsAdminUser(fullName))
PrintCommands(plugin.AdminCommands, nick);
return;
}
throw new Exception("I'm not 100% sure what you were getting at by feeding me a ton of parameters...i'm just going to choke.");
}
public static void IrcClientListCallback(object sender, IrcEventArgs e)
{
if (e.Data.ReplyCode == ReplyCode.List) {
Console.WriteLine("On the IRC channel "+CHANNEL+" are "+e.Data.RawMessageArray[4]+" users");
e.Data.Irc.Disconnect();
}
}
public override void Execute(IrcEventArgs e)
{
if (e.Data.MessageArray.Count() < 3)
{
e.Data.Irc.SendMessage(SendType.Message, e.Data.Nick, "Missing parameters");
return;
}
User user = userService.GetAuthenticatedUser(e.Data.From);
if (user != null && user.UserLevel == 10)
{
int userLevel = 1;
if (e.Data.MessageArray.Count() > 3)
int.TryParse(e.Data.MessageArray[3], out userLevel);
if (userService.CreateUser(e.Data.MessageArray[1], e.Data.MessageArray[2], userLevel) > 0)
{
e.Data.Irc.SendMessage(SendType.Message, e.Data.Nick, "User created");
}
else
{
e.Data.Irc.SendMessage(SendType.Message, e.Data.Nick, "User already exists");
}
}
else
{
e.Data.Irc.SendMessage(SendType.Message, e.Data.Nick, "You do not have authorization to use this command");
return;
}
}
public static bool Load(string trigger, IrcEventArgs e, out IrcTrigger ircTrigger)
{
ircTrigger = new IrcTrigger();
Regex regex = new Regex(string.Format(triggerFormat, trigger), RegexOptions.IgnoreCase);
Match m = regex.Match(e.Data.Message);
if(m.Success)
{
ircTrigger.Channel = e.Data.Channel;
ircTrigger.Nick = e.Data.Nick;
ircTrigger.Host = e.Data.Host;
ircTrigger.Message = m.Groups["args"].Value;
ircTrigger.Arguments =
(ircTrigger.Message.Length > 0 ?
ircTrigger.Message.Split(new char[] { ' ' }) :
new string[0]
);
ircTrigger.Trigger = m.Groups["trigger"].Value;
return true;
}
return false;
}
public override void ProcessMessage(IrcEventArgs e)
{
if (e.Data.MessageArray[0] == "!resetBlackjack")
{
Reset();
return;
}
if (CurrentState == States.NO_GAME && (e.Data.MessageArray[0]=="!jack" || e.Data.MessageArray[0] == "!blackjack"))
{
//start new game
currentPlayer = e.Data.Nick;
Deal();
CurrentState = States.CARDS_DEALT;
TellPlayerOfHands();
}
else if (CurrentState == States.CARDS_DEALT && e.Data.Nick == currentPlayer)
{
ParseCommand(e);
}
}
public void ExecuteCommands(IrcEventArgs ircEventArgs, List<IBotCommand> commands)
{
foreach (IBotCommand command in commands)
{
bool shouldExecuteCommand = false;
try
{
shouldExecuteCommand = command.ShouldExecuteCommand(ircEventArgs);
}
catch (Exception e)
{
SendMessage(string.Format("Command threw and exception: {0}", e.Message), ircEventArgs.Data.Nick);
}
if (shouldExecuteCommand)
{
try
{
command.Execute(ircEventArgs);
}
catch (Exception e)
{
SendMessage(e.Message, ircEventArgs.Data.Nick);
PrintHelpSyntaxForCommand(ircEventArgs, command);
}
}
}
}
public static void OnMessage(object sender, IrcEventArgs e)
{
string[] foulwords = new string[1];
Console.ForegroundColor = ConsoleColor.Yellow;
//highlighting
if (e.Data.Message.Contains(Config.User) == true)
{
Console.ForegroundColor = ConsoleColor.Green;
System.Console.WriteLine(e.Data.From + " : " + e.Data.Message);
}
else if (e.Data.From.Contains(Config.User) == true)
{
Console.ForegroundColor = ConsoleColor.Red;
System.Console.Write(e.Data.From + ": ");
Console.ResetColor();
Console.Write(e.Data.Message + "\n");
}
else if (foulwords.Any(p => e.Data.Message.Contains(p)))
{
Console.ForegroundColor = ConsoleColor.Red;
System.Console.Write(e.Data.From + ": ");
Console.ResetColor();
Console.Write(e.Data.Message + "\n");
}
else
{
System.Console.Write(e.Data.From + ": ");
Console.ResetColor();
Console.Write(e.Data.Message + "\n");
}
}
public override void Execute(IrcEventArgs e)
{
string message = "";
// If parameter is given, show help message of command <parameter>
if (e.Data.MessageArray.Count() > 1 && commands.ContainsKey(commandIdentifier + e.Data.MessageArray[1]))
message = commands[commandIdentifier + e.Data.MessageArray[1]].Name + ": " + commands[commandIdentifier + e.Data.MessageArray[1]].Help;
else
{
// Else list available commands
message = "Available commands: ";
foreach (ICommand command in commands.Values.Distinct())
{
message += command.Name;
if (command.Aliases != null)
message += " (" + string.Join(", ", command.Aliases) + ")";
if (command != commands.Values.Last())
message += ", ";
}
}
e.Data.Irc.SendMessage(SendType.Message, e.Data.Channel, message);
}
public static void banned_word_check(object sender, IrcEventArgs e)
{
if (badwords.Contains(e.Data.Message))
{
if (InDB(e.Data.Nick, settings.serverlist, e.Data.Channel) == false)
{
int i = rng.Next(kickreasons.Length + 1);
InsertEntry(e.Data.Nick, settings.serverlist, e.Data.Channel);
irc.RfcKick(e.Data.Channel, e.Data.Nick, kickreasons[i]);
}
else
{
if (GetKicks(e.Data.Nick, e.Data.Channel, settings.serverlist) >= 5) //ban nick if kicked 5 times.
{
irc.Ban(e.Data.Channel, e.Data.Host);
irc.RfcKick(e.Data.Channel, e.Data.Nick, "banned");
}
else
{
int i = rng.Next(kickreasons.Length + 1);
irc.RfcKick(e.Data.Channel, e.Data.Nick, kickreasons[i]);
UpdateKicks(e.Data.Nick, settings.serverlist, e.Data.Channel);
}
}
}
}
public override IEnumerable<string> Execute(IrcEventArgs e)
{
string nick = "";
string message = "";
if (e.Data.MessageArray.Count() > 1)
{
nick = e.Data.MessageArray[1];
}
else
{
nick = store.GetUserSetting<string>(e.Data.Nick, "LastfmUsername");
if (string.IsNullOrWhiteSpace(nick))
nick = e.Data.Nick;
}
log.Info("Fetching now playing information for user \"" + nick + "\"");
try
{
message = FetchNowPlayingInfo(nick);
}
catch (Exception)
{
return new string[0];
}
return new[] { message };
}
public override void Execute(IrcEventArgs args)
{
string channel = args.Data.Channel;
var currentGame = TriviaPlugin.GetGameForChannel(channel);
if (currentGame != null && currentGame.GameStarted)
{
if (!currentGame.UsersAttempted.Contains(args.Data.From)
|| currentGame.CurrentQuestion.Answers.Count == 1)
{
if (IsCorrectAnswer(args.Data.Message, currentGame.CurrentQuestion))
{
string cAnswer = currentGame.CurrentQuestion.GetCorrectAnswer().AnswerText;
currentGame.SendMessage(channel, string.Format("Correct! {0} got the answer right! It was: {1}", MessageFormatting.MakeNavyBlue(args.Data.Nick), MessageFormatting.MakeHotPink(cAnswer)));
//todo give the dude some points
currentGame.GotoNextQuestion();
}
else
{
if (!currentGame.UsersAttempted.Contains(args.Data.From))
currentGame.UsersAttempted.Add(args.Data.From);
}
}
}
}
public void OnRawMessage(object sender, IrcEventArgs e)
{
AddItemToLog("Received: " + e.Data.RawMessage);
if (e.Data.Type == ReceiveType.ChannelMessage)
{
nummsg = nummsg + 1;
}
}
private void _ircClient_OnPrivmsg(object sender, SIRC4N.IrcEventArgs e)
=> PrivMessageReceived?.Invoke(new PrivMessage()
{
ChannelName = e.Data.Channel,
Text = e.Data.Message,
UserHostName = e.Data.Host,
UserName = e.Data.Nick
});
public static void OnQueryMessage(object sender, IrcEventArgs e)
{
switch (e.Data.MessageArray[0])
{
// debug stuff
case "dump_channel":
string requested_channel = e.Data.MessageArray[1];
// getting the channel (via channel sync feature)
Channel channel = irc.GetChannel(requested_channel);
// here we send messages
irc.SendMessage(SendType.Message, e.Data.Nick, "<channel '" + requested_channel + "'>");
irc.SendMessage(SendType.Message, e.Data.Nick, "Name: '" + channel.Name + "'");
irc.SendMessage(SendType.Message, e.Data.Nick, "Topic: '" + channel.Topic + "'");
irc.SendMessage(SendType.Message, e.Data.Nick, "Mode: '" + channel.Mode + "'");
irc.SendMessage(SendType.Message, e.Data.Nick, "Key: '" + channel.Key + "'");
irc.SendMessage(SendType.Message, e.Data.Nick, "UserLimit: '" + channel.UserLimit + "'");
// here we go through all users of the channel and show their
// hashtable key and nickname
string nickname_list = "";
nickname_list += "Users: ";
foreach (DictionaryEntry de in channel.Users)
{
string key = (string) de.Key;
ChannelUser channeluser = (ChannelUser) de.Value;
nickname_list += "(";
if (channeluser.IsOp)
{
nickname_list += "@";
}
if (channeluser.IsVoice)
{
nickname_list += "+";
}
nickname_list += ")" + key + " => " + channeluser.Nick + ", ";
}
irc.SendMessage(SendType.Message, e.Data.Nick, nickname_list);
irc.SendMessage(SendType.Message, e.Data.Nick, "</channel>");
break;
case "gc":
GC.Collect();
break;
// typical commands
case "join":
irc.RfcJoin(e.Data.MessageArray[1]);
break;
case "part":
irc.RfcPart(e.Data.MessageArray[1]);
break;
case "die":
Exit();
break;
}
}
private void _ircClient_OnRawMessage(object sender, SIRC4N.IrcEventArgs e)
=> MessageReceived?.Invoke($"RAW: {e.Data.RawMessage}");
private void MeebyIrc_OnErrorMessage(object sender, Meebey.SmartIrc4net.IrcEventArgs e)
{
parent.ThreadSafeAddPreviewText("! " + e.Data.Message + " !", LineType.IrcCommand);
}
