private void HandleNamesReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 4);
if (split.Length != 4)
{
_logger.Error("Names reply with less than 4 parameters.");
return;
}
Channel channel = GetChannel(split[2]) as Channel;
String[] nicks = split[3].Substring(1).Split(' ');
foreach (String nick in nicks)
{
char mode = ChannelUserMode.SymbolToMode(nick[0]);
if (mode != char.MinValue)
{
User user = GetUser(nick.Substring(1)) as User;
ChannelUser channelUser = AddUserToChannel(user, channel);
channelUser.Modes.AddMode(mode);
}
else
{
User user = GetUser(nick) as User;
ChannelUser channelUser = AddUserToChannel(user, channel);
}
}
}
public void Reply(IReceiveMessage message, IMessageTarget sender, ReplyForm replyForm, object result)
{
IMessageTarget target = ReplyTarget(message);
ISendMessage sendMessage = ReplyMessage(message.Connection.MessageSender, target, replyForm, result);
if(replyForm != ReplyForm.More)
{
String[] messages = SplitMessage(sendMessage).ToArray();
if(messages.Length > _data.ReplyMores)
{
_moreMessages.Remove(sender);
_moreMessages.Add(sender, new Queue<String>(messages.Skip(_data.ReplyMores)));
_lastMore = sender;
}
message.Connection.SendAndForget(messages
.Take(_data.ReplyMores)
.Select(s => SendMessage(sendMessage, s, sender, replyForm))
);
}
else
{
message.Connection.SendAndForget(SendMessage(sendMessage, sendMessage.Contents, sender,
_bot.DefaultReplyForm));
}
}
private void HandleWelcome(IReceiveMessage message)
{
String nickname = message.Contents.Split(new[] { ' ' }, 2)[0];
ChangeNickname(_me, nickname);
_me.Network.Value = message.Sender as Network;
}
public async ValueTask <object> TestReceive(object message, IReceiveMessage receiver)
{
switch (message)
{
case TestPacket1 packet1:
Console.WriteLine($"Remote{Index}:接收消息{nameof(TestPacket1)}--{packet1.Value}");
return(new TestPacket2 {
Value = packet1.Value
});
case TestPacket2 packet2:
Console.WriteLine($"Remote{Index}:接收消息{nameof(TestPacket2)}--{packet2.Value}");
if (packet2.Value == 0)
{
stopwatch.Restart();
}
if (packet2.Value == MessageCount - 1)
{
stopwatch.Stop();
Console.WriteLine($"Remote{Index}:TestReceive{MessageCount} ------ {stopwatch.ElapsedMilliseconds}----- 每秒:{MessageCount * 1000 / (stopwatch.ElapsedMilliseconds +1)}");
}
return(null);
default:
break;
}
return(null);
}
public void ShouldReturnAResult()
{
string message = "41 04 15";
IReceiveMessage result = _response.Parse(message);
Assert.IsNotNull(result);
}
public void ShouldGetTheCommand()
{
const string expectedCommand = "4105";
IReceiveMessage response = _response.Parse(Message);
Assert.AreEqual(expectedCommand, response.Command);
}
private void HandleChannelModeChange(IReceiveMessage message)
{
Channel channel = message.Receiver as Channel;
String[] split = message.Contents.Split(new[] { ' ' }, 2);
if (split.Length == 1)
{
channel.Modes.ParseAndApply(split[0]);
}
else
{
ModeChange[] changes = Mode.Parse(split[0]);
String[] nicknames = split[1].Split(' ');
if (changes.Length != nicknames.Length)
{
_logger.Error("Length of changes does not match length of nicknames.");
return;
}
for (int i = 0; i < changes.Length; ++i)
{
ChannelUser channelUser = channel.GetUser(nicknames[i]) as ChannelUser;
channelUser.Modes.Apply(changes[i]);
}
}
}
public void Process(IReceiveMessage message)
{
if (OnProcessMessage != null)
{
OnProcessMessage(message);
}
}
public MessageContainer(T MessageIdentifier, IReceiveMessage ReceiverObject, Predicate <object> ConditionPredicate = null)
: base(MessageIdentifier, ConditionPredicate)
{
this.MessageIdentifier = MessageIdentifier;
this.ReceiverObject = ReceiverObject;
this.ConditionPredicate = ConditionPredicate;
}
private void HandlePart(IReceiveMessage message)
{
ChannelUser channelUser = message.Sender as ChannelUser;
Channel channel = message.Receiver as Channel;
RemoveUserFromChannel(channelUser.User as User, channel);
}
public void ShouldReadTheCommand()
{
string message = "41 2F 55";
string expectedCommand = "412F";
IReceiveMessage result = _response.Parse(message);
Assert.AreEqual(expectedCommand, result.Command);
}
public IReceiveMessage Receive(String raw)
{
if (raw == null)
{
throw new ArgumentNullException("raw");
}
if (String.IsNullOrWhiteSpace(raw))
{
throw new ArgumentException("Not an IRC line", "raw");
}
// Remove first :
String line = null;
if (raw[0] == ':')
{
line = raw.Substring(1);
}
else
{
line = raw;
}
// Try to parse messages without prefixes.
IReceiveMessage message = ParseNoPrefixMessage(line);
if (message != null)
{
return(message);
}
// Tokenize
String[] tokens = line.Split(new [] { ' ' }, 3);
String prefix = tokens[0];
String command = tokens[1];
String parameters = String.Empty;
if (tokens.Length == 3)
{
parameters = tokens[2];
}
// Parse sender
IMessageTarget sender = ParseSender(prefix);
// Parse message type
Tuple <ReceiveType, ReplyType> type = ParseMessageType(command);
// Parse message
if (type.Item1 != ReceiveType.Unknown)
{
return(ParseInformationMessage(sender, type.Item1, type.Item2, parameters));
}
else
{
return(ParseMessage(sender, line.Substring(prefix.Length + 1)));
}
}
private void ProcessMessage(IReceiveMessage response)
{
if (this.tbResponses.InvokeRequired)
{
var d = new SetTextCallback(this.ProcessMessage);
this.Invoke(d, new object[] { response });
}
else
{
this.tbResponses.Text += response.Data + "\r\n";
}
}
private void HandleNickChange(IReceiveMessage message)
{
User user = message.Sender as User;
foreach (IChannel channel in user.Channels)
{
_receivedMessages.OnNext(_client.CreateReceiveMessage(this, message.Contents, message.Date,
message.Sender, channel, message.Type, message.ReplyType));
}
ChangeNickname(user, message.Contents);
}
public void Match(IContext context, IReceiveMessage message)
{
Match match = Regex.Match(message.Contents);
if(!match.Success)
return;
String[] arguments = match.Groups
.As<System.Text.RegularExpressions.Group>()
.Skip(1)
.Select(g => g.Value)
.ToArray()
;
context.Bot.Output(context, message, Expression.Evaluate(context, arguments), false);
}
private void HandleQuit(IReceiveMessage message)
{
User user = message.Sender as User;
Channel[] channels = user.Channels.Cast <Channel>().ToArray();
foreach (Channel channel in channels)
{
_receivedMessages.OnNext(_client.CreateReceiveMessage(this, message.Contents, message.Date,
message.Sender, channel, message.Type, message.ReplyType));
RemoveUserFromChannel(user, channel);
}
_users.Remove(user);
}
public void SubscribeByMessageType <T>(IReceiveMessage ReceiverObject)
where T : MessageBase
{
var FoundMessages = from message in MessagesByType
where message.ReceiverObject == ReceiverObject
select message;
int FoundMessagesCount = FoundMessages.Count();
if (FoundMessagesCount == 0)
{
MessagesByType.Add(new MessageContainer <Type>(typeof(T), ReceiverObject));
}
}
private void HandleChannelModeIsReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 3);
if (split.Length != 3)
{
_logger.Error("Channel mode reply with less than 3 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
channel.Modes.ParseAndApply(split[2]);
}
private void HandleTopicReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 3);
if (split.Length != 3)
{
_logger.Error("Topic reply with less than 3 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
channel.Topic.Value = split[2].Substring(1);
}
private void HandleCreatedAtReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 3);
if (split.Length != 3)
{
_logger.Error("Channel mode reply with less than 3 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
uint timestamp;
if (uint.TryParse(split[2], out timestamp))
{
channel.CreatedDate.Value = timestamp;
}
}
private IReceiveMessage ParseNoPrefixMessage(String line)
{
IReceiveMessage message = null;
message = ParseUndirectedMessage(PingRegex, ReceiveType.Ping, Connection.Me.Network.Value, line,
Connection.Me);
if (message != null)
{
return(message);
}
message = ParseUndirectedMessage(ErrorRegex, ReceiveType.Error, Connection.Me.Network.Value, line,
Connection.Me);
if (message != null)
{
return(message);
}
return(message);
}
private void VerifyCounter(IReceiveMessage message)
{
//TODO
//this might need a little more logic, now I'm just checking if current counter-1 = previous counter
//this generates onMessageLost after runing if for first time
if (message.Counter - _previousCounterValue > 1)
{
if (_lostDataCount < int.MaxValue)
{
_lostDataCount++;
}
base.MessageLostOccured?.Invoke(this, new MessageLostEventArgs()
{
TotalLostCount = _lostDataCount
});
}
_previousCounterValue = message.Counter;
}
public void SubscribeByMessageTypeAndCondition <T>(IReceiveMessage ReceiverObject, Predicate <object> ConditionPredicate)
where T : MessageBase
{
if (ConditionPredicate == null)
{
throw new Exception("The ConditionPredicate entered can not be null.");
}
var FoundMessages = from message in MessagesByType
where message.ReceiverObject == ReceiverObject
select message;
int FoundMessagesCount = FoundMessages.Count();
if (FoundMessagesCount == 0)
{
MessagesByType.Add(new MessageContainer <Type>(typeof(T), ReceiverObject, ConditionPredicate));
}
}
private void HandleJoin(IReceiveMessage message)
{
ChannelUser channelUser = message.Sender as ChannelUser;
Channel channel = message.Receiver as Channel;
AddUserToChannel(channelUser.User as User, channel);
if (_me.Equals(channelUser.User))
{
this.SendAndForget(
_messageSender.Mode(channel)
, _messageSender.Who(channel.Name)
);
}
else
{
this.SendAndForget(_messageSender.Who(channelUser.Name));
}
}
public static async ValueTask <object> DealMessage(object message, IReceiveMessage receiver)
{
switch (message)
{
case string str:
return($"{str} world");
case Login2Gate login:
Console.WriteLine($"客户端登陆请求：{login.Account}-----{login.Password}");
Login2GateResult resp = new Login2GateResult();
resp.IsSuccess = true;
return(resp);
default:
break;
}
return(null);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public virtual IResponseMessage Process()
{
var messageHandler = new QyMessageHandler();
_receiveMessage = XmlHelper.Deserialize <ReceiveMessageBase>(_xmlMessage);
switch (_receiveMessage.MsgType)
{
case ReceiveMessageType.text:
_receiveMessage = XmlHelper.Deserialize <ReceiveMessageText>(_xmlMessage);
return((messageHandler as IMessageHandler <ReceiveMessageText>).Handle(_receiveMessage as ReceiveMessageText));
//break;
case ReceiveMessageType.image:
_receiveMessage = XmlHelper.Deserialize <ReceiveMessageImage>(_xmlMessage);
return((messageHandler as IMessageHandler <ReceiveMessageImage>).Handle(_receiveMessage as ReceiveMessageImage));
//break;
case ReceiveMessageType.voice:
_receiveMessage = XmlHelper.Deserialize <ReceiveMessageVoice>(_xmlMessage);
return((messageHandler as IMessageHandler <ReceiveMessageVoice>).Handle(_receiveMessage as ReceiveMessageVoice));
//break;
case ReceiveMessageType.video:
break;
case ReceiveMessageType.location:
break;
case ReceiveMessageType.@event:
break;
case ReceiveMessageType.link:
break;
default:
break;
}
return(null);
}
private void HandleTopicSetByReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 4);
if (split.Length != 4)
{
_logger.Error("Topic set by reply with less than 3 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
IIdentity identity = Identity.Parse(split[2]); // TODO: Search by identity and not nickname?
if (identity != null)
{
String nickname = null;
if (!String.IsNullOrWhiteSpace(identity.Name))
{
nickname = identity.Name;
}
if (!String.IsNullOrWhiteSpace(identity.Host)) // For the case where it is a nickname, not an identity.
{
nickname = identity.Host;
}
if (nickname != null)
{
IUser user = GetUser(nickname);
channel.TopicSetBy.Value = user;
}
}
uint timestamp;
if (uint.TryParse(split[3], out timestamp))
{
channel.TopicSetDate.Value = timestamp;
}
}
public void StartConsumer(string queueName, IReceiveMessage callback)
{
this.queueName = queueName;
this.receiver = callback;
string queueUrl = string.Empty;
try
{
queueUrl = getQueueUrl(queueName);
receiveMessageRequest = new ReceiveMessageRequest();
receiveMessageRequest.QueueUrl = queueUrl;
receiveMessageRequest.MessageAttributeNames = new List <string> {
"All"
};
receiveMessageRequest.MaxNumberOfMessages = 10;//max
_queueUrl = queueUrl;
}
catch (Exception e)
{
throw new Exception("Fail to initialize Consumer: " + e.Message);
}
_workerThread = new Thread(new ThreadStart(this.start));
_workerThread.Start();
}
public void Output(IContext context, IReceiveMessage message, IObservable<object> output,
bool replySuccess = true)
{
bool reply = false;
output
.ToString(context.Seperator)
.Subscribe
(
str =>
{
_replyHandler.Reply(message, context.Sender, context.ReplyForm, str);
reply = true;
},
e =>
{
_replyHandler.Reply(message, context.Sender, context.ReplyForm, e);
reply = true;
},
() =>
{
if(!reply && _data.ReplySuccess && replySuccess)
_replyHandler.Reply(message, context.Sender, context.ReplyForm, "The operation succeeded.");
}
);
}
private void HandleAwayReply(IReceiveMessage message)
{
_me.Away.Value = true;
}
private void HandleChannelModeIsReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 3);
if(split.Length != 3)
{
_logger.Error("Channel mode reply with less than 3 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
channel.Modes.ParseAndApply(split[2]);
}
private static void PrintMessage(IReceiveMessage message)
{
_logger.Info(message.Type.ToString() + "," + message.ReplyType.ToString() + " - " +
message.Sender.ToString() + " :: " + message.Receiver + " :: " + message.Contents);
}
private String ProcessPrefix(IReceiveMessage message, bool privateMessage)
{
String contents = message.Contents;
if(privateMessage)
return contents;
if(String.IsNullOrWhiteSpace(contents) || contents.Length < 2)
return null;
foreach(char prefix in _data.AddressedCharacters)
if(contents[0] == prefix)
return contents.Substring(1);
if(_data.AddressedNickame)
{
String nickname = message.Connection.Me.Name;
if(contents.Length > nickname.Length + 2 && contents.StartsWith(nickname))
{
contents = contents.Substring(nickname.Length);
if(contents[0] == ':' || contents[0] == ',')
return contents.Substring(1);
}
}
return null;
}
private void HandleJoin(IReceiveMessage message)
{
ChannelUser channelUser = message.Sender as ChannelUser;
Channel channel = message.Receiver as Channel;
AddUserToChannel(channelUser.User as User, channel);
if(_me.Equals(channelUser.User))
{
this.SendAndForget(
_messageSender.Mode(channel)
, _messageSender.Who(channel.Name)
);
}
else
{
this.SendAndForget(_messageSender.Who(channelUser.Name));
}
}
private void HandleTopicReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 3);
if(split.Length != 3)
{
_logger.Error("Topic reply with less than 3 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
channel.Topic.Value = split[2].Substring(1);
}
private void HandleTopicChange(IReceiveMessage message)
{
Channel channel = message.Receiver as Channel;
channel.Topic.Value = message.Contents;
}
private void HandleUnAwayReply(IReceiveMessage message)
{
_me.Away.Value = false;
}
private void HandleTopicSetByReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 4);
if(split.Length != 4)
{
_logger.Error("Topic set by reply with less than 3 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
IIdentity identity = Identity.Parse(split[2]); // TODO: Search by identity and not nickname?
if(identity != null)
{
String nickname = null;
if(!String.IsNullOrWhiteSpace(identity.Name))
nickname = identity.Name;
if(!String.IsNullOrWhiteSpace(identity.Host)) // For the case where it is a nickname, not an identity.
nickname = identity.Host;
if(nickname != null)
{
IUser user = GetUser(nickname);
channel.TopicSetBy.Value = user;
}
}
uint timestamp;
if(uint.TryParse(split[3], out timestamp))
{
channel.TopicSetDate.Value = timestamp;
}
}
private void HandleUserModeChange(IReceiveMessage message)
{
User user = message.Receiver as User;
user.Modes.ParseAndApply(message.Contents);
}
private void HandleWelcome(IReceiveMessage message)
{
String nickname = message.Contents.Split(new[] { ' ' }, 2)[0];
ChangeNickname(_me, nickname);
_me.Network.Value = message.Sender as Network;
}
private void HandleWhoReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 9);
if(split.Length != 9)
{
_logger.Error("Who reply with less than 9 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
User user = GetUser(split[5]) as User;
ChannelUser channelUser = channel.GetUser(user.Name) as ChannelUser;
user.Identity.Ident.Value = split[2];
user.Identity.Host.Value = split[3];
user.Network.Value = GetNetwork(split[4]);
bool away = false;
bool serverOp = false;
bool channelVoice = false;
bool channelOp = false;
foreach(char c in split[6])
{
switch(c)
{
case 'H': away = false; break;
case 'G': away = true; break;
case '*': serverOp = true; break;
case '@': channelOp = true; break;
case '+': channelVoice = true; break;
}
}
user.Away.Value = away;
// TODO: proper server operator mode.
if(serverOp)
user.Modes.AddMode('o');
else
user.Modes.RemoveMode('o');
if(channelVoice)
channelUser.Modes.AddMode('v');
else
channelUser.Modes.RemoveMode('v');
if(channelOp)
channelUser.Modes.AddMode('o');
else
channelUser.Modes.RemoveMode('o');
// TODO: hop count.
user.RealName.Value = split[8];
}
private void HandleAwayReply(IReceiveMessage message)
{
_me.Away.Value = true;
}
private void HandleQuit(IReceiveMessage message)
{
User user = message.Sender as User;
Channel[] channels = user.Channels.Cast<Channel>().ToArray();
foreach(Channel channel in channels)
{
_receivedMessages.OnNext(_client.CreateReceiveMessage(this, message.Contents, message.Date,
message.Sender, channel, message.Type, message.ReplyType));
RemoveUserFromChannel(user, channel);
}
_users.Remove(user);
}
private void HandleUnAwayReply(IReceiveMessage message)
{
_me.Away.Value = false;
}
private void HandlePing(IReceiveMessage message)
{
this.SendAndForget(_messageSender.Pong(message.Contents));
}
public void ReceivedMessage(IReceiveMessage message)
{
try
{
bool privateMessage = message.Receiver.Equals(message.Connection.Me);
String contents = ProcessPrefix(message, privateMessage);
ConversionContext conversionContext = new ConversionContext { Bot = _bot, Message = message };
IUser sender = message.Sender as IUser ?? (message.Sender as IChannelUser).User;
IBotUser botUser = _bot.Authentication.GetUser(sender);
IChannel channel = message.Receiver as IChannel;
Context context = new Context
{
Bot = _bot
, Connection = message.Connection
, Sender = sender
, Channel = channel
, User = botUser
, Contents = contents ?? message.Contents
, Allowed = command => Allowed(command, privateMessage, botUser)
, ConversionContext = conversionContext
, CallDepth = 0
, ReplyForm = privateMessage ? ReplyForm.Echo : _bot.DefaultReplyForm
, Seperator = "; "
};
if(contents == null)
{
_messages.OnNext(Tuple.Create<IContext, IReceiveMessage>(context, message));
return;
}
try
{
ICallable callable = _bot.Command.Call(contents);
if(callable == null)
return;
_bot.Output(context, message, context.Evaluate(callable), true);
}
catch(NoCommandNameException e)
{
if(_data.ReplyNoCommand)
_replyHandler.Reply(message, sender, _bot.DefaultReplyForm, e);
}
catch(NoCommandException e)
{
if(_data.ReplyNoCommand)
_replyHandler.Reply(message, sender, _bot.DefaultReplyForm, e);
}
catch(AmbiguousCommandsException e)
{
if(_data.ReplyAmbiguousCommands)
_replyHandler.Reply(message, sender, _bot.DefaultReplyForm, e);
}
catch(IncorrectArgumentsException e)
{
if(_data.ReplyIncorrectArguments)
_replyHandler.Reply(message, sender, _bot.DefaultReplyForm, e);
}
catch(Exception e)
{
_replyHandler.Reply(message, sender, _bot.DefaultReplyForm, e);
}
}
catch(Exception e)
{
_logger.ErrorException("Error executing: \"" + message.Contents + "\".", e);
}
}
private void HandlePart(IReceiveMessage message)
{
ChannelUser channelUser = message.Sender as ChannelUser;
Channel channel = message.Receiver as Channel;
RemoveUserFromChannel(channelUser.User as User, channel);
}
private void HandleCreatedAtReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 3);
if(split.Length != 3)
{
_logger.Error("Channel mode reply with less than 3 parameters.");
return;
}
Channel channel = GetChannel(split[1]) as Channel;
uint timestamp;
if(uint.TryParse(split[2], out timestamp))
{
channel.CreatedDate.Value = timestamp;
}
}
private void HandleNickChange(IReceiveMessage message)
{
User user = message.Sender as User;
foreach(IChannel channel in user.Channels)
{
_receivedMessages.OnNext(_client.CreateReceiveMessage(this, message.Contents, message.Date,
message.Sender, channel, message.Type, message.ReplyType));
}
ChangeNickname(user, message.Contents);
}
public void ShouldReturnNullIfInvalidCommand()
{
IReceiveMessage response = _response.Parse("41 00 3C");
Assert.IsNull(response);
}
private void HandleNamesReply(IReceiveMessage message)
{
String[] split = message.Contents.Split(new[] { ' ' }, 4);
if(split.Length != 4)
{
_logger.Error("Names reply with less than 4 parameters.");
return;
}
Channel channel = GetChannel(split[2]) as Channel;
String[] nicks = split[3].Substring(1).Split(' ');
foreach(String nick in nicks)
{
char mode = ChannelUserMode.SymbolToMode(nick[0]);
if(mode != char.MinValue)
{
User user = GetUser(nick.Substring(1)) as User;
ChannelUser channelUser = AddUserToChannel(user, channel);
channelUser.Modes.AddMode(mode);
}
else
{
User user = GetUser(nick) as User;
ChannelUser channelUser = AddUserToChannel(user, channel);
}
}
}
private void HandleChannelModeChange(IReceiveMessage message)
{
Channel channel = message.Receiver as Channel;
String[] split = message.Contents.Split(new[] { ' ' }, 2);
if(split.Length == 1)
{
channel.Modes.ParseAndApply(split[0]);
}
else
{
ModeChange[] changes = Mode.Parse(split[0]);
String[] nicknames = split[1].Split(' ');
if(changes.Length != nicknames.Length)
{
_logger.Error("Length of changes does not match length of nicknames.");
return;
}
for(int i = 0; i < changes.Length; ++i)
{
ChannelUser channelUser = channel.GetUser(nicknames[i]) as ChannelUser;
channelUser.Modes.Apply(changes[i]);
}
}
}
private void LogUserError(IReceiveMessage message, Exception e)
{
_logger.InfoException("Error executing: \"" + message.Contents + "\".", e);
}
private static void PrintMessage(IReceiveMessage message)
{
_logger.Info(message.Type.ToString() + "," + message.ReplyType.ToString() + " - " +
message.Sender.ToString() + " :: " + message.Receiver + " :: " + message.Contents);
}
private void HandleKick(IReceiveMessage message)
{
ChannelUser channelUser = message.Receiver as ChannelUser;
RemoveUserFromChannel(channelUser);
}
private IMessageTarget ReplyTarget(IReceiveMessage message)
{
if(message.Receiver.Equals(message.Connection.Me))
return message.Sender;
else
return message.Receiver;
}
public void Reply(IReceiveMessage message, IMessageTarget sender, ReplyForm replyForm, Exception e)
{
LogUserError(message, e);
if(!_data.ReplyError)
return;
if(_data.ReplyErrorDetailed)
Reply(message, sender, replyForm, "Error -- " + e.Message);
else
Reply(message, sender, replyForm, "An error occurred.");
}
