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."); }