public async Task HandleCommand(IListener listener, IRespondable respondTo, IList <string> args, LinkedMessage e)
{
SendOptions opts = new SendOptions();
try{
opts.Parse(args);
string msg = opts.Parameters.Count > 0 ? LilGUtil.ArgJoiner(opts.Parameters.ToArray()) : opts.Parameters[0];
if (opts.Raw)
{
LinkedIrcMessage message = (LinkedIrcMessage)e;
message.Client.SendRawMessage(msg);
return;
}
if (opts.channelId != 0)
{
DiscordChannel channel = await Program.Config.DiscordSocketClient.GetChannelAsync(opts.channelId);
await channel.SendMessageAsync(msg);
return;
}
if (opts.channel != null)
{
LinkedIrcMessage message = (LinkedIrcMessage)e;
if (message.Client.Channels.Contains(opts.channel))
{
message.Client.SendMessage(msg, opts.channel);
}
}
} catch (GetOptException) { await Help(listener, respondTo, args, e); }
}
private async void OnChannelMessageRecieved(PrivateMessageEventArgs e)
{
LinkedIrcChannel channel = e.PrivateMessage.Channel;
LinkedIrcMessage message = e;
LogMessage(channel, message);
bool isCommand = await CommandHandler(e);
if (!isCommand)
{
await Program.CommandList.message(this, channel, message);
}
Logger.Info("{0} from {1} by {2}: {3}",
isCommand ? "Command" : "Message",
e.PrivateMessage.Source,
e.PrivateMessage.User.Hostmask,
e.PrivateMessage.Message);
}
public async Task <bool> CommandHandler(PrivateMessageEventArgs e)
{
if (e.PrivateMessage.User.Hostmask == IrcSelf.Hostmask)
{
return(false);
}
string message = e.PrivateMessage.Message;
string messageLower = message.ToLower();
string[] args = message.SplitMessage();
IRespondable respondTo;
if (e.PrivateMessage.IsChannelMessage)
{
respondTo = (LinkedIrcChannel)e.PrivateMessage.Channel;
}
else
{
respondTo = (LinkedIrcUser)e.PrivateMessage.User;
}
string first = args[0].ToLower();
bool commandByName = first.StartsWith(IrcSelf.Nick.ToLower());
bool commandByPrefix = messageLower.StartsWithAny(Config.CommandPrefixes);
if (commandByName || commandByPrefix)
{
string command = null;
int offset = 1;
if (commandByName)
{
if (args.Length < 2)
{
return(false);
}
command = args[1];
offset = 2;
}
if (commandByPrefix)
{
foreach (string prefix in Config.CommandPrefixes)
{
if (messageLower.StartsWith(prefix))
{
if (prefix.EndsWith(" "))
{
if (args.Length < 2)
{
return(false);
}
command = args[1];
offset = 2;
break;
}
command = args[0].Substring(prefix.Length);
break;
}
}
}
if (command == null)
{
return(false);
}
if (Program.CommandList.ContainsCommand(command))
{
LinkedIrcMessage linkedMessage = e;
if (!LilGUtil.CheckPermission(command, linkedMessage))
{
await respondTo.respond($"Sorry, you don't have the permission to run {command}");
return(true);
}
ICommand icommand = Program.CommandList[command];
ArraySegment <string> segment = new ArraySegment <string>(args, offset, args.Length - offset);
try{ await icommand.HandleCommand(this, respondTo, segment, (LinkedIrcMessage)e); } catch (Exception ex) {
Logger.Error(ex, "Problem processing command: \n{0}", ex.StackTrace);
await respondTo.respond($"Sorry there was a problem processing the command: {ex.Message}");
return(true);
}
return(true);
}
}
return(false);
}
