public static void HandleJoinCommand(AlarisMainParameter mp, string chan)
{
if (Rfc2812Util.IsValidChannelName(chan))
mp.IrcConnection.Sender.Join(chan);
return;
}
public static void HandleHelpCommand(AlarisMainParameter mp)
{
mp.IrcConnection.Sender.PublicMessage(mp.Channel,
"{0}: info | quit | sys | join | title | calc | sort | admin",
"Available commands");
return;
}
public static void TestAddHandler(AlarisMainParameter mp, string a, string b)
{
var ar = Convert.ToInt32(a);
var br = Convert.ToInt32(b);
mp.IrcConnection.Sender.PublicMessage(mp.Channel, string.Format("Result: {0}", ar + br));
}
public static void HandleAesCommands(AlarisMainParameter mp, params string[] parameters)
{
var action = parameters[0];
var sb = new StringBuilder();
for(var i = 1; i < parameters.Length; ++i)
sb.AppendFormat("{0} ", parameters[i]);
var text = sb.ToString();
if (action.IsNull() || text.IsNull())
return;
if (action.Equals("decrypt", StringComparison.InvariantCultureIgnoreCase))
{
mp.Bot.SendMsg(mp.Channel, Rijndael.DecryptString(text));
}
else if(action.Equals("encrypt", StringComparison.InvariantCultureIgnoreCase))
HandleAesEncryptCommand(mp, text);
}
public static void HandleWACommand(AlarisMainParameter mp, params string[] parameters)
{
var expression = parameters.ConcatenateWithSpaces();
expression = expression.Replace("=", " = "); // for equations
var client = new WAClient("557QYQ-UUUWTKX95V");
/*var result = client.GetResult(expression);
var results = from pod in result.Pods
where pod.Title.ToLower().Contains("solution")
|| pod.Title.ToLower().Contains("result")
|| pod.Title.ToLower().Contains("derivative")
select pod;
foreach (var rs in results.Select(pod => pod.SubPods[0].PlainText))
{
mp.Bot.SendMsg(mp.Channel, rs);
}*/
var result = client.Solve(expression);
mp.Bot.SendMsg(mp.Channel, result);
}
public static void HandleCallCommand(AlarisMainParameter mp, params string[] parameters)
{
var methodName = parameters[0];
var pars = new ArrayList();
for(var i = 1; i < parameters.Length; ++i)
{
pars.Add(parameters[i]);
}
var atype = AlarisBase.Instance.GetType();
var method = atype.GetMethods().FirstOrDefault(minfo => minfo.Name.Equals(methodName,
StringComparison.InvariantCultureIgnoreCase)
&& minfo.GetParameters().Length == pars.Count);
if(method == null)
{
Log.Info("Specified method {0} is not found inside AlarisBot matching parameter count {1}", methodName, pars.Count);
}
else
{
try
{
var ret = method.Invoke(AlarisBase.Instance, pars.ToArray());
if(ret != null) // probably void
mp.IrcConnection.Sender.PublicMessage(mp.Channel, ret.ToString());
}
catch(Exception x)
{
Log.ErrorException(string.Format("Exception thrown while calling the specified method ({0})", x.Message), x);
}
return;
}
Log.Debug("Searching for method in all available assemblies. (Parameter count is {0})", pars.Count);
var asms = AlarisBase.Instance.AddonManager.Assemblies.ToList();
asms.Add(AlarisBase.Instance.GetType().Assembly);
asms.AddRange(from asm in AppDomain.CurrentDomain.GetAssemblies()
where asm.GetName().FullName.ToLower().Contains("alaris")
select asm);
foreach (var type in asms.SelectMany(asm => asm.GetTypes()))
{
foreach(var mi in type.GetMethods(BindingFlags.Static | BindingFlags.InvokeMethod))
{
if(mi.Name.Equals(methodName, StringComparison.InvariantCultureIgnoreCase) && mi.GetParameters().Length == pars.Count)
{
method = mi;
break;
}
}
}
if(method != null)
{
try
{
var ret = method.Invoke(null, pars.ToArray());
if (method.ReturnType == typeof(string))
mp.IrcConnection.Sender.PublicMessage(mp.Channel, ret as string);
}
catch (Exception x)
{
Log.ErrorException(string.Format("Exception thrown while calling the specified method ({0})", x.Message), x);
}
}
}
public static void HandleListMethodsCommand(AlarisMainParameter mp)
{
var sb = new StringBuilder();
foreach(var type in Assembly.GetExecutingAssembly().GetTypes())
{
foreach(var mi in type.GetMethods(BindingFlags.Public | BindingFlags.InvokeMethod))
{
sb.AppendFormat("{0}.{1}({2})", type.Name, mi.Name, mi.GetParameters().Length);
}
}
var fl = sb.ToString();
if(!string.IsNullOrEmpty(fl))
mp.IrcConnection.Sender.PublicMessage(mp.Channel, fl);
}
public static void HandleListAssembliesCommand(AlarisMainParameter mp)
{
var sb = new StringBuilder();
foreach(var asm in AppDomain.CurrentDomain.GetAssemblies())
sb.AppendFormat("{0} ", asm.GetName().Name);
var fn = sb.ToString();
mp.IrcConnection.Sender.PublicMessage(mp.Channel, fn);
}
public static void HandleSysCommand(AlarisMainParameter mp)
{
Utility.SendSysStats(mp.Channel);
return;
}
public static void HandleQuitCommand(AlarisMainParameter mp)
{
mp.Bot.Disconnect("Quit command used by " + mp.User.Nick);
return;
}
public static void HandleInfoCommand(AlarisMainParameter mp)
{
Utility.SendInfo(mp.Channel);
return;
}
/// <summary>
/// Handles the command.
/// </summary>
/// <param name="user">The irc user</param>
/// <param name="channel">IRC channel</param>
/// <param name="message">IRC msg.</param>
public void HandleCommand(UserInfo user, string channel, string message)
{
try
{
if (!message.StartsWith(CommandPrefix))
return;
var commandText = message.Remove(0, 1); // remove prefix
Log.Info("Checking for command: {0}", commandText);
if(_commandMethodMap.Count <= 5)
foreach (var entry in _commandMethodMap)
Log.Info("Mapping contains command: {0}", entry.Key.Command);
var wr = commandText.Split(' ');
var command = wr[0];
var parameters = new List<string>();
for (var i = 1; i < wr.Length; ++i)
{
parameters.Add(wr[i]);
}
var perm = CommandPermission.Normal;
AlarisMethod handler = null;
AlarisCommandWrapper cmd = null;
foreach (var entry in _commandMethodMap.AsParallel().Where(entry => entry.Key.Command.Equals(command, StringComparison.InvariantCultureIgnoreCase)))
{
perm = entry.Key.Permission;
handler = entry.Value;
cmd = entry.Key;
}
if (handler == null)
return;
if (parameters.Count != 0 && !handler.IsParameterized)
return;
if (perm == CommandPermission.Admin && !Utility.IsAdmin(user))
return;
Log.Info("The handler {0} parameterized. It is about to be called with {1} params",
(handler.IsParameterized ? "is" : "is not"), parameters.Count);
var mp = new AlarisMainParameter
{
Channel = channel,
Channels = AlarisBase.Instance.Channels,
IrcConnection = AlarisBase.Instance.Connection,
User = user
};
var parl = new List<object>();
if(handler.IsParameterized)
{
parl.Add(mp);
if (!cmd.IsParameterCountUnspecified)
{
parl.AddRange(parameters);
var pdiff = handler.Method.GetParameters().Length - (parl.Count + 1);
if (pdiff > 0)
{
for (var i = 0; i <= pdiff; ++i)
parl.Add(null);
}
}
}
else
parl.Add(mp);
/*object[] passParams = handler.IsParameterized
? new object[] {mp, parameters.ToArray()}
: new object[] {mp};*/
if(handler.IsParameterized && cmd.IsParameterCountUnspecified)
{
var prms = new ArrayList {mp, parameters.ToArray()};
Log.Info("Invoking command handler method ({0}) ({1})", handler.Method.Name, prms.Count);
handler.Method.Invoke(null, prms.ToArray());
return;
}
Log.Info("Invoking command handler method ({0}) ({1})", handler.Method.Name, parl.Count);
handler.Method.Invoke(null, parl.ToArray());
}
catch(Exception x)
{
Log.ErrorException(string.Format("Exception thrown during command recognition ({0})", x), x);
return;
}
}
public static void HandleListCmdsCommand(AlarisMainParameter mp)
{
}
public static void HandleTestCommand(AlarisMainParameter mp)
{
mp.IrcConnection.Sender.PublicMessage(mp.Channel, "Test command called.");
}
public static void HandleAesEncryptCommand(AlarisMainParameter mp, string text)
{
mp.Bot.SendMsg(mp.Channel, Rijndael.EncryptString(text));
}
public static void HandleAddCommand(AlarisMainParameter mp, string a, string b)
{
mp.Bot.SendMsg(mp.Channel, (a.Cast<int>() + b.Cast<int>()).ToString());
}