/// <summary> /// Creates an instance of <see cref="ChatMessageEventArgs"/>. /// </summary> /// <param name="sender">The sender, or <c>null</c> if the message has no sender.</param> /// <param name="recipient">The recipient.</param> /// <param name="message">The chat message.</param> public ChatMessageEventArgs(IrcIdentity sender, IrcString recipient, IrcString message) : base(sender, recipient) { Throw.If.Null(message, "message"); Message = message; }
internal static bool ValidateIdentity(IrcIdentity identity, out string errorMessage) { errorMessage = null; if (identity.Nickname == null || identity.Nickname.Length == 0) { errorMessage = "Nickname is not set."; return(false); } if (!ValidateIdentityPart(identity.Nickname, out errorMessage)) { return(false); } if (identity.Username != null && !ValidateIdentityPart(identity.Username, out errorMessage)) { return(false); } if (identity.Hostname != null && !ValidateIdentityPart(identity.Hostname, out errorMessage)) { return(false); } return(true); }
private void ProcessQuit(IrcIdentity ident, string channelName, SpamConfig channel) { var nickname = ident.Nickname; Whois.NormalizeIdentity(ident); var quits = channel.AddUserPart(ident.ToString(), channel.QuitsThresholdSeconds); if (quits < channel.QuitsThreshold) { return; } channel.ResetUserPart(ident.ToString()); Log.WriteInfo("Spam", "'{1}' ({0}) is spamming joins/quits in {2}. Redirecting for {3} minutes.", nickname, ident, channelName, channel.QuitsBanMinutes); Bootstrap.Client.Client.Mode(channelName, "+b", ident + "$" + Bootstrap.Client.Settings.RedirectChannel); // In case they manage to come back before ban takes place Bootstrap.Client.Client.Kick(nickname, channelName, string.Format("Fix your connection. Banned for {0} minutes", channel.QuitsBanMinutes)); Bootstrap.Client.Client.Notice(nickname, string.Format("You have been banned from {0} for {1} minutes for rapidly rejoining the channel.", channelName, channel.QuitsBanMinutes)); Bootstrap.Client.ModeList.AddLateModeRequest( new LateModeRequest { Channel = channelName, Recipient = ident.ToString(), Mode = "-b", Time = DateTime.UtcNow.AddMinutes(channel.QuitsBanMinutes), Reason = "Quit/leave flood" } ); }
/// <summary> /// Creates a new instance of <see cref="KickEventArgs"/>. /// </summary> /// <param name="sender">The user doing the kicking.</param> /// <param name="recipient">The user being kicked out of the channel.</param> /// <param name="channel">The channel the user is being kicked from.</param> /// <param name="reason">The reason the user is being kicked, or <c>null</c> if none is given.</param> public KickEventArgs(IrcIdentity sender, IrcString recipient, IrcString channel, IrcString reason) : base(sender, recipient) { Throw.If.Null(channel, "channel"); Channel = channel; Reason = reason; }
public static IrcIdentity NormalizeIdentity(IrcIdentity originalIdent) { var ident = new IrcIdentity { Hostname = originalIdent.Hostname, Nickname = originalIdent.Nickname, Username = originalIdent.Username, }; if (ident.Username == null) { ident.Username = "******"; } if (ident.Hostname == null) { ident.Hostname = "*"; } else if (ident.Hostname != "*") { //ident.Username = "******"; } // We don't want to accidentally ban *!*@* if (ident.Username != "*" || ident.Hostname != "*") { ident.Nickname = "*"; } return(ident); }
/// <summary> /// Creates a new instance of <see cref="ModeEventArgs"/>. /// </summary> /// <param name="sender">The user changing the mode.</param> /// <param name="recipient">The target of the mode change. This may be a channel or a user.</param> /// <param name="command">The mode change, for example +o or +v.</param> /// <param name="parameters">The mode change parameters.</param> public ModeEventArgs(IrcIdentity sender, IrcString recipient, IrcString command, IrcString[] parameters) : base(sender, recipient) { Throw.If.Null(command, "command").NullElements(parameters, "parameters"); Command = command; _parameters = (IrcString[])parameters.Clone(); }
/// <summary> /// Creates a new instance of <see cref="InvitationEventArgs"/>. /// </summary> /// <param name="sender">The sender of the invitation.</param> /// <param name="recipient">The recipient of the invitation.</param> /// <param name="channel">The channel the invitation is for.</param> public InvitationEventArgs(IrcIdentity sender, IrcString recipient, IrcString channel) : base(sender, recipient) { Throw.If.Null(channel, "channel"); Channel = channel; }
public override void OnCommand(CommandArguments command) { var nick = command.Arguments.Groups["nick"].Value; if (!IrcIdentity.TryParse(nick, out var ident)) { command.Reply("Invalid identity."); return; } var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient); if (!channel.WeAreOpped) { if (channel.HasChanServ) { Bootstrap.Client.Client.Message("ChanServ", string.Format("op {0}", channel.Name)); } else { command.Reply("I'm not opped, send help."); return; } } var isQuiet = command.MatchedCommand != "unban"; Bootstrap.Client.Whois.Query(ident, whoisData => { if (whoisData.Identity.Nickname != null) { ident = whoisData.Identity; Whois.NormalizeIdentity(ident); } else { if (ident.Username == null) { ident.Username = "******"; } if (ident.Hostname == null) { ident.Hostname = "*"; } } Log.WriteInfo("Unban", "'{0}' unbanned '{1}' in {2}", command.Event.Sender, ident, command.Event.Recipient); Bootstrap.Client.Client.Mode(command.Event.Recipient, isQuiet ? "-q" : "-b", ident); command.ReplyAsNotice("{0} {1}", isQuiet ? "Unmuted" : "Unbanned", ident); } ); }
public override void OnCommand(CommandArguments command) { var nick = command.Arguments.Groups["nick"].Value; if (nick.Length == 0 || !IrcIdentity.TryParse(nick, out var ident)) { ident = command.Event.Sender; } Bootstrap.Client.Whois.Query(ident, whoisData => { if (whoisData.Identity.Nickname == null) { command.Reply("There is no user by that nick on the network."); return; } ident = whoisData.Identity; if (ident.Nickname.ToString().ToLowerInvariant() == Bootstrap.Client.TrueNickname.ToLowerInvariant()) { command.Reply("That's me, dummy."); return; } if (!Users.TryGetUser(ident, out var user)) { command.Reply("This user has no permissions."); return; } var permissions = new List <string>(); if (user.Permissions.ContainsKey("*")) { permissions.AddRange(user.Permissions["*"]); } if (user.Permissions.ContainsKey(command.Event.Recipient)) { permissions.AddRange(user.Permissions[command.Event.Recipient]); } if (!permissions.Any()) { command.Reply("This user has no permissions in this channel."); return; } command.Reply("{0} has following permissions in this channel: {1}", ident.Nickname, string.Join(", ", permissions.Distinct())); } ); }
public User(IrcIdentity user) { this.user = user; this.NewBotId(); this.HasBeenPresented = false; this.TalkTo = false; this.Translate = false; this.Language = null; }
public static string GetReceiver(IrcIdentity sender, Channel channel) { if (null != channel) { return channel.Name; } return sender.Username; }
public override void OnCommand(CommandArguments command) { var nick = command.Arguments.Groups["nick"].Value; if (!IrcIdentity.TryParse(nick, out var ident)) { command.Reply("Invalid identity."); return; } if (string.Equals(ident.Nickname.ToString(), Bootstrap.Client.TrueNickname, StringComparison.InvariantCultureIgnoreCase)) { command.Reply("Don't you even dare."); return; } var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient); if (!channel.WeAreOpped) { if (channel.HasChanServ) { Bootstrap.Client.Client.IrcCommand("CHANSERV", "op", channel.Name); } else { command.Reply("I'm not opped, send help."); return; } } var reason = command.Arguments.Groups["reason"].Value.Trim(); if (command.MatchedCommand == "duckoff" && reason.Length == 0) { reason = "Quack, motherducker"; } Log.WriteInfo("Kick", "'{0}' kicked '{1}' in {2} (reason: {3})", command.Event.Sender, ident, command.Event.Recipient, reason.Length == 0 ? "no reason given" : reason); if (command.MatchedCommand == "remove") { Bootstrap.Client.Client.Remove(ident.Nickname, command.Event.Recipient, reason.Length == 0 ? null : reason); } else { Bootstrap.Client.Client.Kick(ident.Nickname, command.Event.Recipient, reason.Length == 0 ? null : reason); } command.ReplyAsNotice("Kicked {0}", ident); }
public void AddAction(IrcIdentity sender, string message) { LastActions.Enqueue( new ChatAction { Identity = sender, Message = message.ToLowerInvariant(), Time = DateTime.UtcNow, } ); }
public void Query(IrcIdentity ident, Action <WhoisData> callback) { if (ident.Username != null || ident.Hostname != null) { var data = new WhoisData(); data.Identity = ident; callback.Invoke(data); } else { QueryAccount(ident, callback); } }
public override void OnCommand(CommandArguments command) { var nicks = new List <IrcString>(); var input = command.Arguments.Groups["nicks"].Value; if (input.Length == 0) { nicks.Add(command.Event.Sender.Nickname); } else { var nicksTemp = input.Split(' '); foreach (var nick in nicksTemp) { if (!IrcIdentity.TryParse(nick, out var ident)) { command.Reply("'{0}' is a invalid indentity.", nick); return; } nicks.Add(ident.Nickname); } } var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient); if (channel.WeAreOpped) { Bootstrap.Client.Client.Mode(command.Event.Recipient, "+" + new string('o', nicks.Count), nicks.ToArray()); } else if (channel.HasChanServ) { Bootstrap.Client.Client.IrcCommand("CHANSERV", "op", channel.Name, string.Join(" ", nicks)); } else { command.Reply("I'm not opped, send help."); return; } Log.WriteInfo("Op", "'{0}' gave channel operator to {1} in {2}", command.Event.Sender, string.Join(", ", nicks), command.Event.Recipient); }
private void ProcessQuit(IrcIdentity ident, string channelName, SpamConfig channel) { var nickname = ident.Nickname; ident = Whois.NormalizeIdentity(ident); var quits = channel.AddUserPart(ident.ToString(), channel.QuitsThresholdSeconds); if (quits < channel.QuitsThreshold) { return; } var banMinutes = channel.AddUserBan(ident.ToString()) * channel.QuitsBanMinutes; Log.WriteInfo("Spam", "'{1}' ({0}) is spamming joins/quits in {2}. Redirecting for {3} minutes.", nickname, ident, channelName, banMinutes); Bootstrap.Client.Client.Mode(channelName, "+b", ident + "$" + Bootstrap.Client.Settings.RedirectChannel); // In case they manage to come back before ban takes place Bootstrap.Client.Client.Kick(nickname, channelName, $"Fix your connection. Banned for {banMinutes} minutes"); Bootstrap.Client.Client.Notice(nickname, $"Please fix your connection. You have been banned from {channelName} for {banMinutes} minutes for rapidly rejoining the channel."); if (Bootstrap.Client.ModeList.Find(channelName, ident.ToString(), "-b") != null) { Log.WriteInfo("Spam", "There's already a latemode set for '{0}' in {1}", ident, channelName); return; } Bootstrap.Client.ModeList.AddLateModeRequest( new LateModeRequest { Channel = channelName, Recipient = ident.ToString(), Mode = "-b", Time = DateTime.UtcNow.AddMinutes(banMinutes), Reason = "Quit/leave flood" } ); }
private void QueryAccount(IrcIdentity ident, Action <WhoisData> callback) { WhoisData data; if (Pending.ContainsKey(ident.Nickname)) { data = Pending[ident.Nickname]; } else { data = new WhoisData(); Pending.Add(ident.Nickname, data); // TODO: create a timeout? } data.Callbacks.Add(callback); Bootstrap.Client.Client.Whois(ident.Nickname); }
public static void NormalizeIdentity(IrcIdentity ident) { if (ident.Username == null) { ident.Username = "******"; } if (ident.Hostname == null) { ident.Hostname = "*"; } else if (ident.Hostname.StartsWith("gateway/web/freenode/ip.")) { var temp = ident.Hostname.ToString().Split('/'); ident.Hostname = temp[3].Substring(3); //ident.Nickname = "*"; ident.Username = "******"; } else if (ident.Hostname.StartsWith("gateway/")) { ident.Hostname = "gateway/*"; // IRCCloud: uid indicates a free account, paid accounts have the prefix sid. if (ident.Username.StartsWith("uid") || ident.Username.StartsWith("sid")) { ident.Username = "******" + ident.Username.Substring(1); } } else if (ident.Hostname != "*") { ident.Username = "******"; } // We don't want to accidentally ban *!*@* if (ident.Username != "*" || ident.Hostname != "*") { ident.Nickname = "*"; } }
internal static void Dispatch(string commandName, string[] parameters, IrcIdentity sender, ServerUser serverUser, Channel channel) { if (CommandList.ContainsKey(commandName)) { var command = CommandList[commandName]; var commandParameters = new CommandParameters { CommandName = commandName, Parameters = parameters, Sender = sender, ServerUser = serverUser, Channel = channel, Command = command }; command.Function(commandParameters); } else { var commandCompressed = commandName; if (null != parameters && parameters.Length > 0) { commandCompressed += string.Format(" ({0})", string.Join(",", parameters)); } Debug.WriteLine( string.Format( "Unknown command {0} (from {1})", commandCompressed, (sender != null) ? sender.Nickname.ToString() : "Anonymous"), null != channel ? channel.ToString() : serverUser.ToString()); var message = string.Format( "Unknown command {0}", commandCompressed); serverUser.SendMessage(Command.GetReceiver(sender, channel), message); } }
/// <summary> /// Creates a new instance of <see cref="TargetedMessageEventArgs"/>. /// </summary> /// <param name="sender">The sender, or <c>null</c> if the message has no sender.</param> /// <param name="recipient">The recipient.</param> public TargetedMessageEventArgs(IrcIdentity sender, IrcString recipient) { Throw.If.Null(recipient, "recipient"); Sender = sender; Recipient = recipient; }
public WhoisData() { Identity = new IrcIdentity(); Callbacks = new List <Action <WhoisData> >(); }
public override void OnCommand(CommandArguments command) { var nick = command.Arguments.Groups["nick"].Value; if (!IrcIdentity.TryParse(nick, out var ident)) { command.Reply("Invalid identity."); return; } var duration = command.Arguments.Groups["duration"].Value; var durationTime = default(DateTime); if (duration.Length > 0) { try { durationTime = DateTimeParser.Parse(duration, command.Arguments.Groups["durationUnit"].Value); } catch (ArgumentException e) { command.Reply("{0}", e.Message); return; } } var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient); if (!channel.WeAreOpped) { if (channel.HasChanServ) { Bootstrap.Client.Client.IrcCommand("CHANSERV", "op", channel.Name); } else { command.Reply("I'm not opped, send help."); return; } } var isQuiet = command.MatchedCommand == "quiet" || command.MatchedCommand == "mute"; Bootstrap.Client.Whois.Query(ident, whoisData => { if (whoisData.Identity.Nickname == null) { command.Reply("There is no user by that nick on the network. Try {0}!*@* to {1} anyone with that nick, or specify a full hostmask.", ident.Nickname, isQuiet ? "quiet" : "ban"); return; } ident = whoisData.Identity; var nickname = ident.Nickname; if (string.Equals(nickname.ToString(), Bootstrap.Client.TrueNickname, StringComparison.InvariantCultureIgnoreCase)) { command.Reply("Don't you even dare."); return; } ident = Whois.NormalizeIdentity(ident); if (Bootstrap.Client.ModeList.Find(command.Event.Recipient, ident.ToString(), isQuiet ? "-q" : "-b") != null) { command.Reply("{0} is already {1} in this channel.", ident, isQuiet ? "muted" : "banned"); return; } Log.WriteInfo("Ban", "'{0}' {1} '{2}' from {3}", command.Event.Sender, isQuiet ? "quieted" : "banned", ident, command.Event.Recipient); var reason = command.Arguments.Groups["reason"].Value.Trim(); if (reason.Length == 0) { reason = $"Banned by {command.Event.Sender.Nickname}"; } Bootstrap.Client.Client.Mode(command.Event.Recipient, isQuiet ? "+q" : "+b", ident); if (!isQuiet && channel.HasUser(nickname)) { Bootstrap.Client.Client.Kick(nickname, command.Event.Recipient, reason); } if (duration.Length > 0) { command.ReplyAsNotice("Will {0} {1} {2}", isQuiet ? "unmute" : "unban", ident, durationTime.ToRelativeString()); Bootstrap.Client.ModeList.AddLateModeRequest( new LateModeRequest { Channel = command.Event.Recipient, Recipient = ident.ToString(), Sender = command.Event.Sender.ToString(), Mode = isQuiet ? "-q" : "-b", Time = durationTime, Reason = reason } ); } else { command.ReplyAsNotice("{0} {1}", isQuiet ? "Muted" : "Banned", ident); } } ); }
public static bool TryGetUser(IrcIdentity ident, out User user) { return(UsersList.TryGetValue(string.Format("{0}@{1}", ident.Username, ident.Hostname), out user)); }
private static bool IsWhitelisted(IrcIdentity ident, string channel) { // If this user has a "spam.whitelist" permission, allow them to spam return(Users.TryGetUser(ident, out var user) && user.HasPermission(channel, "spam.whitelist")); }
/// <summary> /// Creates a new instance of <see cref="PingReplyEventArgs"/>. /// </summary> /// <param name="identity">The user who is replying to your ping request.</param> /// <param name="delay">The ping time, in milliseconds.</param> public PingReplyEventArgs(IrcIdentity identity, int delay) { Throw.If.Null(identity, "identity").Negative(delay, "delay"); Identity = identity; Delay = delay; }
/// <summary> /// Tries to read a buffer and parse out an IRC statement. /// Additionally, on failure, the reason for failure is returned. /// </summary> /// <param name="buffer">The buffer to read from.</param> /// <param name="offset">The offset to begin reading. The parser may advance this, even if parsing fails.</param> /// <param name="count">The maximum number of bytes to read.</param> /// <param name="statement">The statement, if parsing succeeds, or <c>null</c>.</param> /// <param name="parseResult">The result of parsing. On failure, this is the reason for the failure.</param> /// <returns><c>true</c> if parsing succeeded.</returns> public static bool TryParse(byte[] buffer, ref int offset, int count, out IrcStatement statement, out IrcStatementParseResult parseResult) { Throw.If.Null(buffer, "buffer"); string errorMessage = null; IrcString[] parts; statement = null; parseResult = IrcStatementParseResult.NothingToParse; // First, skip all initial CR/LF. SkipCrlf(buffer, ref offset, ref count); // See if we've got a CR or LF anywhere. int crlfIndex = IrcString.IndexOf(buffer, @byte => @byte == 13 || @byte == 10, offset, count); if (crlfIndex == -1) { if (count >= IrcConstants.MaxStatementLength) { parseResult = IrcStatementParseResult.StatementTooLong; } return(false); } // OK, let's get our string. var @string = new IrcString(buffer, offset, crlfIndex - offset); #if DEBUG var debugString = @string; #endif offset += @string.Length + 1; count -= @string.Length + 1; SkipCrlf(buffer, ref offset, ref count); if (crlfIndex >= IrcConstants.MaxStatementLength) { parseResult = IrcStatementParseResult.StatementTooLong; return(false); } // Do we have a prefix? statement = new IrcStatement(); if (@string.Length >= 1 && @string[0] == (byte)':') { parts = @string.Split((byte)' ', 2); var sourceString = parts[0].Substring(1); IrcIdentity source; if (!IrcIdentity.TryParse(sourceString, out source)) { goto invalid; } statement.Source = source; @string = parts.Length >= 2 ? parts[1] : IrcString.Empty; } // Now get the command. parts = @string.Split((byte)' ', 2); statement.Command = parts[0]; @string = parts.Length >= 2 ? parts[1] : IrcString.Empty; // Parameters, now... while (@string.Length > 0) { if (@string[0] == (byte)':') { statement.Parameters.Add(@string.Substring(1)); break; } else { parts = @string.Split((byte)' ', 2); statement.Parameters.Add(parts[0]); if (parts.Length == 1) { break; } @string = parts[1]; } } // We're done. If everything's kosher, we'll return true. if (!IrcValidation.ValidateStatement(statement, out errorMessage)) { goto invalid; } parseResult = IrcStatementParseResult.OK; return(true); invalid: #if DEBUG Console.WriteLine("Invalid statement '{0}' (error '{1}').", debugString, errorMessage); #endif statement = null; parseResult = IrcStatementParseResult.InvalidStatement; return(false); }
/// <summary> /// The on message. /// </summary> /// <param name="messageType"> /// The message type. /// </param> /// <param name="message"> /// The message. /// </param> /// <param name="sender"> /// The sender. /// </param> internal void OnMessage(EventDispatcher.MessageType messageType, string message, IrcIdentity sender) { if (this.ServerUser.IsMe(sender)) { return; } if (messageType == EventDispatcher.MessageType.Message) { Commands.Interprete(message, sender, this.ServerUser, this); } else { Debug.WriteLine( string.Format( "Message \"{0}\" (from {1})", message, (sender != null) ? sender.Nickname.ToString() : "Anonymous"), this.ToString()); } }
public override void OnCommand(CommandArguments command) { var nick = command.Arguments.Groups["nick"].Value; if (!IrcIdentity.TryParse(nick, out var ident)) { command.Reply("Invalid identity."); return; } var channel = Bootstrap.Client.ChannelList.GetChannel(command.Event.Recipient); if (!channel.WeAreOpped) { if (channel.HasChanServ) { Bootstrap.Client.Client.Message("ChanServ", string.Format("op {0}", channel.Name)); } else { command.Reply("I'm not opped, send help."); return; } } Bootstrap.Client.Whois.Query(ident, whoisData => { if (whoisData.Identity.Nickname != null) { ident = whoisData.Identity; } var nickname = ident.Nickname; if (nickname.ToString().ToLowerInvariant() == Bootstrap.Client.TrueNickname.ToLowerInvariant()) { command.Reply("Don't you even dare."); return; } if (whoisData.Identity.Nickname != null) { Whois.NormalizeIdentity(ident); } else { if (ident.Username == null) { ident.Username = "******"; } if (ident.Hostname == null) { ident.Hostname = "*"; } } var targetChannel = command.Arguments.Groups["channel"].Value.Trim(); if (targetChannel.Length == 0) { targetChannel = Bootstrap.Client.Settings.RedirectChannel; } else if (!IrcValidation.IsChannelName(targetChannel)) { command.Reply("Invalid target channel."); return; } if (Bootstrap.Client.ModeList.Find(command.Event.Recipient, ident.ToString(), "-b") != null) { command.Reply("{0} is already banned in this channel.", ident); return; } Log.WriteInfo("Redirect", "'{0}' redirected '{1}' from {2} to {3}", command.Event.Sender, ident, command.Event.Recipient, targetChannel); var reason = string.Format("Redirected to {0} by {1} for 2 hours", targetChannel, command.Event.Sender.Nickname); Bootstrap.Client.Client.Mode(command.Event.Recipient, "+b", ident + "$" + targetChannel); if (channel.HasUser(nickname)) { Bootstrap.Client.Client.Kick(nickname, command.Event.Recipient, reason); } command.ReplyAsNotice("Redirected {0} to {1} for 2 hours", ident, targetChannel); Bootstrap.Client.ModeList.AddLateModeRequest( new LateModeRequest { Channel = command.Event.Recipient, Recipient = ident.ToString(), Sender = command.Event.Sender.ToString(), Mode = "-b", Time = DateTime.UtcNow.AddHours(2), Reason = reason } ); } ); }
/// <summary> /// Creates a new instance of <see cref="JoinLeaveEventArgs"/>. /// </summary> /// <param name="identity">The user who joined or left the channel(s).</param> /// <param name="channels">The list of channels joined or left.</param> public JoinLeaveEventArgs(IrcIdentity identity, IrcString[] channels) { Throw.If.Null(identity, "identity").NullElements(channels, "channels"); Identity = identity; _channels = (IrcString[])channels.Clone(); }
/// <summary> /// Creates an IRC statement. /// </summary> /// <param name="source">The source of the statement, if any. This is called the prefix in the IRC specification.</param> /// <param name="command">The command or three-digit reply code.</param> /// <param name="parameters">The parameters of the command.</param> public IrcStatement(IrcIdentity source, IrcString command, params IrcString[] parameters) { Source = source; Command = command; Parameters = new List <IrcString>(parameters); }
/// <summary> /// The on leave join. /// </summary> /// <param name="isJoin"> /// The is join. /// </param> /// <param name="identity"> /// The identity. /// </param> internal void OnLeaveJoin(bool isJoin, IrcIdentity identity) { Debug.WriteLine(string.Format("{0} {1}", identity.Nickname, isJoin ? "joined" : "left"), this.ToString()); if (identity.Username == this.ServerUser.UserName) { this.IsActive = isJoin; } else { this.EvaluateUserName(identity.Username); } }
/// <summary> /// Creates a new instance of <see cref="QuitEventArgs"/>. /// </summary> /// <param name="identity">The user who disconnected.</param> /// <param name="quitMessage">The quit message, or <c>null</c> if none was given.</param> public QuitEventArgs(IrcIdentity identity, IrcString quitMessage) { Throw.If.Null(identity, "identity"); Identity = identity; QuitMessage = quitMessage; }
/// <summary> /// The on command. /// </summary> /// <param name="messageType"> /// The message type. /// </param> /// <param name="command"> /// The command. /// </param> /// <param name="parameters"> /// The parameters. /// </param> /// <param name="sender"> /// The sender. /// </param> internal void OnCommand(EventDispatcher.MessageType messageType, string command, string[] parameters, IrcIdentity sender) { CommandDispatcher.Dispatch(command, parameters, sender, this.ServerUser, this); }
/// <summary> /// The interprete. /// </summary> /// <param name="message"> /// The message. /// </param> /// <param name="sender"> /// The sender. /// </param> /// <param name="serverUser"> /// The server user. /// </param> /// <param name="channel"> /// The channel. /// </param> internal static void Interprete(string message, IrcIdentity sender, ServerUser serverUser, Channel channel) { if (null == sender) { return; } var user = User.GetOrCreate(sender); if (user.Translate) { var language = Services.DetectLanguage(message, false, user.Language == null ? 0.1 : 0.3); if ((language != null) && (language != "en")) { user.Language = language; } if (user.Language != null) { message = Services.Translate(user.Language, "en", message); channel.SendMessage(string.Format("{0} ({1}): {2}", user.NickName, user.Language, message)); } } if (!user.TalkTo) { return; } var answer = AskBot( ChatBot.Romulus, message, sender.Username, serverUser.NickName); if (channel != null) { answer = string.Format("-> {0}: {1}", sender.Nickname, answer); } serverUser.SendMessage(Command.GetReceiver(sender, channel), answer); }
public static User GetOrCreate(IrcIdentity user) { if (null == user) { return null; } if (!UserDictionary.ContainsKey(user.Username)) { UserDictionary.Add(user.Username, new User(user)); } return UserDictionary[user.Username]; }
public override void OnCommand(CommandArguments command) { var nick = command.Arguments.Groups["nick"].Value; if (nick.Length == 0 || !IrcIdentity.TryParse(nick, out var ident)) { ident = command.Event.Sender; } Bootstrap.Client.Whois.Query(ident, whoisData => { if (whoisData.Identity.Nickname == null) { command.Reply("There is no user by that nick on the network."); return; } ident = whoisData.Identity; if (string.Equals(ident.Nickname.ToString(), Bootstrap.Client.TrueNickname, StringComparison.InvariantCultureIgnoreCase)) { command.Reply("That's me, dummy."); return; } if (!Users.TryGetUser(ident, out var user)) { if (ident.Nickname == command.Event.Sender) { command.Reply("You have no permissions."); return; } command.Reply($"{ident.Nickname} has no permissions."); return; } var permissions = new List <string>(); if (user.Permissions.ContainsKey("*")) { permissions.AddRange(user.Permissions["*"]); } if (user.Permissions.ContainsKey(command.Event.Recipient)) { permissions.AddRange(user.Permissions[command.Event.Recipient]); } if (ident.Nickname == command.Event.Sender) { if (permissions.Count > 0) { command.Reply($"You have following permissions in this channel: {string.Join(", ", permissions.Distinct())}"); return; } command.Reply("You have no permissions in this channel."); return; } if (permissions.Count > 0) { command.Reply($"{ident.Nickname} has following permissions in this channel: {string.Join(", ", permissions.Distinct())}"); return; } command.Reply($"{ident.Nickname} has no permissions in this channel."); } ); }
public static bool TryGetUser(IrcIdentity ident, out User user) { return(UsersList.TryGetValue($"{ident.Username}@{ident.Hostname}", out user)); }
/// <summary> /// Creates a new instance of <see cref="NameChangeEventArgs"/>. /// </summary> /// <param name="identity">The user who is changing their nickname.</param> /// <param name="newName">The new nickname.</param> public NameChangeEventArgs(IrcIdentity identity, IrcString newName) { Throw.If.Null(identity, "identity").Null(newName, "newName"); Identity = identity; NewName = newName; }
internal bool IsMe(IrcIdentity identity) { return identity.Username == this.UserName; }