public void Initialize()
{
var tup = Initializer.GetAuthenticatedNetwork();
this._network = tup.Item1;
this._wrapper = tup.Item2;
this._channel = this._network.GetChannel("#channel");
}
public CtcpMessage(IrcChannel channel, IrcUser sender, string command, string content, bool isQuery)
{
this.Channel = channel;
this.Sender = sender;
this.Command = command;
this.Content = content;
this.IsQuery = isQuery;
}
// Try and update the topic of the channel after the bot has been privileged
// Useful when the bot joined and wasn't privileged to change the topic and if
// afterwards a user/network service/bot opped the bot, it will try and update the topic
// Bear in mind this will update the status of *any* channel he is given op or higher priv
protected override void OnFlagAdded(IrcUser user, IrcChannel chan, Privilege priv, IrcUser target)
{
if (target == Me && priv >= IrcAddonConfig.RequiredStaffPriv && UpdateTopicOnFlagAdded)
{
Console.WriteLine("Updating topic...");
UpdateTopic(chan);
}
}
public UIChannelConversation(IrcChannelConversation conversation, IrcConversationProvider provider, UIServerConversation serverConversation)
{
_channel = conversation.Channel;
_conversationProvider = provider;
_serverConversation = serverConversation;
conversation.Messages.CollectionChanged += new NotifyCollectionChangedEventHandler(Messages_CollectionChanged);
_channel.People.CollectionChanged += new NotifyCollectionChangedEventHandler(People_CollectionChanged);
}
private void ClientOnLeftChannel(IrcChannel channel)
{
ExecuteOnUiThread(() =>
{
NavItems.Remove(NavItems.FirstOrDefault(vm =>
vm.Label.Equals(channel.Name, StringComparison.InvariantCultureIgnoreCase)));
});
}
protected override void OnText(IrcUser user, IrcChannel chan, StringStream text)
{
if (HideChatting != true)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("({0}) <IRC Interface> {1} <{2}> {3}", DateTime.Now.ToString("hh:mm"), chan, user, text);
}
}
private static void TryExecuteWCellCommand(IrcUser user, IrcChannel chan, string text)
{
var uArgs = user.Args as WCellArgs;
if (uArgs != null && uArgs.CmdArgs != null)
{
WCellUtil.HandleCommand((WCellUser)uArgs.CmdArgs.User, user, chan, text);
}
}
public void Initialize()
{
var tup = Initializer.GetAuthenticatedNetwork(Nickname, RealName);
this._network = tup.Item1;
this._wrapper = tup.Item2;
this._channel = this._network.GetChannel(ChannelName);
}
protected override void OnUserLeftChannel(IrcChannel chan, IrcUser user, string reason)
{
base.OnUserLeftChannel(chan, user, reason);
Console.WriteLine("**{0} quit({1})", user.Nick, reason);
if (user == Me)
{
_watchedChannels.Remove(chan.Name);
}
}
public ChannelEventLogger(IrcChannel channel)
{
this.channel = channel;
channel.UserInvited += Channel_UserInvited;
channel.UserJoined += Channel_UserJoined;
channel.UserKicked += Channel_UserKicked;
channel.UserLeft += Channel_UserLeft;
channel.MessageReceived += Channel_MessageReceived;
}
public override void Run(IIrcUser client, IrcMessage message)
{
string name = message.Params[0];
if (IRC.IsChannel(name))
{
IrcChannel channel = client.IrcServer.GetChannel(message.Params[0]);
if (channel == null)
{
NotFoundError(client, true);
return;
}
if (message.Params.Length < 1)
{
NeedMoreParamsError(client);
return;
}
channel.Mode.Parse(client, message);
return;
}
if (message.Params.Length < 2)
{
NeedMoreParamsError(client);
return;
}
IIrcUser other = client.IrcServer.Clients.Find(user => user.Nick.ToLower() == name.ToLower());
if (other == null)
{
NotFoundError(client, false);
return;
}
string mode = message.Params[1];
if (!((client == other) || client.Mode.IsOperator))
{
PermissionsError(client);
return;
}
other.Mode.Parse(mode);
client.Write(new IrcNumericResponce
{
NumericId = IrcNumericResponceId.RPL_UMODEIS,
To = other.Nick,
Extra = other.Mode.ToString()
});
if (other != client)
{
other.Write(new IrcNumericResponce
{
NumericId = IrcNumericResponceId.RPL_UMODEIS,
To = other.Nick,
Extra = other.Mode.ToString()
});
}
}
private static void InvalidSubmission(IrcChannel channel)
{
invalidSubmission++;
if (invalidSubmission > 2)
{
invalidSubmission = 0;
channel.Client.SendPrivateMessage(MAINCHANNEL, "Submissions closed. Please read http://pastebin.com/WuWarXiC");
}
}
private void JoinChannels()
{
foreach (string channelname in channelnames.Split(new char[] { ';' }))
{
IrcChannel channel = m_IrcClient.JoinChannel(channelname);
channels.Add(channel);
System.Console.WriteLine(String.Format("Joined channel #{0}...",
channel.Name));
}
}
public ChannelBot(IrcChannel channel)
{
Channel = channel;
Channel.UsersListReceived += ChannelOnUsersListReceived;
Channel.UserJoined += ChannelOnUserJoined;
Channel.UserLeft += ChannelOnUserLeft;
Channel.MessageReceived += ChannelOnMessageReceived;
Channel.Client.RawMessageSent += ClientOnRawMessageSent;
}
private ChannelInfoResult GetChannelInfoFromClientChannel(IrcChannel ircchannel)
{
var network = networks.Where(n => n.Client == ircchannel.Client).First();
return(new ChannelInfoResult()
{
Network = network,
Channel = network.Channels.Where(c => c.Name == ircchannel.Name).FirstOrDefault()
});
}
public void Install(IWindsorContainer container, IConfigurationStore store)
{
// Facilities
container.AddFacility <LoggingFacility>(f => f.LogUsing <Log4netFactory>().WithConfig("log4net.xml"));
container.AddFacility <StartableFacility>(f => f.DeferredStart());
container.Install(new WebInstaller());
var ircClientMock = new Mock <IIrcClient>();
ircClientMock.Setup(x => x.ExtBanTypes).Returns("a");
ircClientMock.Setup(x => x.ExtBanDelimiter).Returns("$");
ircClientMock.Setup(x => x.Nickname).Returns("EyeInTheSkyBot");
ircClientMock.Setup(x => x.ClientName).Returns("Freenode");
var ircChannels = new Dictionary <string, IrcChannel>();
var chan = new IrcChannel("##stwalkerster-development");
ircChannels.Add(chan.Name, chan);
ircClientMock.Setup(x => x.Channels).Returns(ircChannels);
IrcUser user;
IrcChannelUser ircChannelUser;
user = IrcUser.FromPrefix("stwalkerster!test@user/.", ircClientMock.Object);
user.Account = "stwalkerster";
user.SkeletonStatus = IrcUserSkeletonStatus.Full;
ircChannelUser = new IrcChannelUser(user, chan.Name);
chan.Users.Add(user.Nickname, ircChannelUser);
user = IrcUser.FromPrefix("chanmember!test@user/.", ircClientMock.Object);
user.Account = "chanmember";
user.SkeletonStatus = IrcUserSkeletonStatus.Full;
ircChannelUser = new IrcChannelUser(user, chan.Name);
chan.Users.Add(user.Nickname, ircChannelUser);
user = IrcUser.FromPrefix("chanop!test@user/.", ircClientMock.Object);
user.Account = "chanop";
user.SkeletonStatus = IrcUserSkeletonStatus.Full;
ircChannelUser = new IrcChannelUser(user, chan.Name);
ircChannelUser.Operator = true;
chan.Users.Add(user.Nickname, ircChannelUser);
container.Register(
// Main application
Component.For <IApplication>().ImplementedBy <Launch>(),
Classes.FromAssemblyNamed("EyeInTheSky").InNamespace("EyeInTheSky.Services").WithServiceAllInterfaces(),
Classes.FromAssemblyNamed("EyeInTheSky").InNamespace("EyeInTheSky.Services.ExternalProviders").WithServiceAllInterfaces(),
Classes.FromAssemblyNamed("EyeInTheSky").InNamespace("EyeInTheSky.Services.Email").WithServiceAllInterfaces(),
Component.For <IIrcClient>().Instance(ircClientMock.Object)
);
container.Install(Configuration.FromXmlFile("alert-templates.xml"));
}
protected override void OnPart(IrcUser user, IrcChannel chan, string reason)
{
if (user == Me)
{
Console.WriteLine("({0}) <IRC Interface> * Bot parts channel {1}", DateTime.Now.ToString("hh:mm"), chan.Name);
}
else
{
Console.WriteLine("({0}) <IRC Interface> * {1} parts channel {2}", DateTime.Now.ToString("hh:mm"), user.Nick, chan.Name);
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="voteQuestion">The string of the vote.</param>
/// <param name="channel">The channel where the vote takes place.</param>
/// <param name="lifeSpan">If null, the vote lasts indefinitely. Else sets the time the vote lasts before ending (seconds)</param>
public Vote(string voteQuestion, IrcChannel channel, int lifeSpan)
{
m_Vote = voteQuestion;
m_Chan = channel;
m_CreationTime = DateTime.Now;
m_Timer = new Timer(lifeSpan * 1000);
m_Timer.AutoReset = false;
m_Timer.Start();
m_Timer.Elapsed += m_Timer_Elapsed;
}
protected override void OnUsersAdded(IrcChannel chan, IrcUser[] users)
{
Console.WriteLine("Topic was set {0} by {1}", chan.TopicSetTime, chan.TopicSetter);
Console.WriteLine("Topic is: {0}", chan.Topic);
foreach (var channel in IrcAddonConfig.UpdatedChannelNames)
{
if (chan.Name == channel)
{
UpdateTopic(chan, chan.Topic);
}
}
}
private void Channel_UserKicked(IrcChannel channel, UserKickedEventArgs args)
{
string text = Locator.Get <ITranslationService>().Translate("Conversation", "Kick", args.KickedUser.Nickname, args.Kicker.Nickname);
if (args.Reason.HasText())
{
text += Locator.Get <ITranslationService>().Translate("Conversation", "Reason", args.Reason);
}
var message = new IrcMessage(channel.Network, MessageDirection.FromServer, args.Kicker, IrcMessageType.Kick, text);
this.AddMessage(message);
}
protected override void OnTopic(IrcUser user, IrcChannel chan, string text, bool initial)
{
Console.ForegroundColor = ConsoleColor.Green;
if (initial)
{
Console.WriteLine("({0}) <IRC Interface> * The topic for channel {1} is {2}", DateTime.Now.ToString("hh:mm"), chan.Name, chan.Topic);
}
else
{
Console.WriteLine("({0}) <IRC Interface> * {1} changed topic in channel {2} to: {3}", DateTime.Now.ToString("hh:mm"), user.Nick, chan.Name, text);
}
}
private IrcConversationViewModel GetConversation(IrcChannel channel)
{
var vm = this.Conversations.FirstOrDefault(c => c.TargetName == channel.FullName);
if (vm == null)
{
vm = new IrcChannelViewModel(channel, this);
this.AddConversation(vm);
}
return(vm);
}
protected override void OnJoin(IrcUser user, IrcChannel chan)
{
Console.ForegroundColor = ConsoleColor.Green;
if (user == Me)
{
Console.WriteLine("({0}) <IRC Interface> * Bot joined channel {1}", DateTime.Now.ToString("hh:mm"), chan.Name);
}
else
{
Console.WriteLine("({0}) <IRC Interface> * {1} joined channel {2}", DateTime.Now.ToString("hh:mm"), user.Nick, chan.Name);
}
}
public void Ban(IrcChannel Channel, TimeSpan Time, params object[] Masks)
{
if (Masks.Length == 0)
return;
string flag = "+";
foreach (string mask in Masks)
{
new UnbanTimer(Channel, mask, Time);
flag += "b";
}
IrcClient.Send("MODE {0} {1} {2}", Channel, flag, Util.GetWords(Masks, 0));
}
public void AddChannel(IrcChannel channel, bool recurse = true)
{
if (!channels.Contains(channel))
{
// GayGeeksBot.Log(String.Format("Adding channel {0} to user {1}", channel.name, nick));
channels.Add(channel);
}
if (recurse)
{
channel.AddUser(this, false);
}
}
public void RemoveChannel(IrcChannel channel, bool recurse = true)
{
if (channels.Contains(channel))
{
// GayGeeksBot.Log(String.Format("Removing channel {0} from user {1}", channel.name, nick));
channels.Remove(channel);
}
if (recurse)
{
channel.RemoveUser(this, false);
}
}
public void AddChannelConversation(IrcChannel channel)
{
if (!ContainsChannelConversation(channel))
{
var conversation = new IrcChannelConversation(_session, channel);
if (!_session.Channels.Contains(channel))
{
_session.Channels.Add(channel);
}
_session.Conversations.Add(conversation);
channel.Join();
}
}
public UsersPanelViewModel(IrcChannel channel, IEventAggregator eventAggregator, IIrcClient ircClient)
{
_eventAggregator = eventAggregator ?? throw new ArgumentNullException(nameof(eventAggregator));
_ircClient = ircClient ?? throw new ArgumentNullException(nameof(ircClient));;
_userMutedEvent = _eventAggregator.GetEvent <UserMutedEvent>();
_userUnmutedEvent = _eventAggregator.GetEvent <UserUnmutedEvent>();
Channel = channel ?? throw new ArgumentException(nameof(channel));
ConnectedUsers.CollectionChanged += ConnectedUsersOnCollectionChanged;
channel.UserJoined += ChannelOnUserJoined;
channel.UserLeft += ChannelOnUserLeft;
channel.UsersListReceived += ChannelOnUsersListReceived;
}
private void ClientOnJoinedChannel(IrcChannel channel)
{
ExecuteOnUiThread(() =>
{
NavItems.Add(new NavigationChannelViewModel
{
Label = channel.Name,
Command = new DelegateCommand(() =>
{
_navigationService.Navigate(PageTokens.Channel.ToString(), channel);
})
});
});
}
public void KickBan(IrcChannel channel, TimeSpan time, params object[] masks)
{
Ban(channel, time, masks);
foreach (string mask in masks)
{
foreach (IrcUser u in channel)
{
if (u.Matches(mask))
{
Kick(channel, u);
}
}
}
}
private static void WhoIsChannel(IrcChannel channel, IrcClient client)
{
foreach (var user in channel.Users)
{
client.WhoIs(user.Nick).AsTask().ContinueWith((task, state) => {
var whois = task.Result;
var userFromState = (IrcUser)state;
userFromState.User = whois.User.User;
userFromState.Hostname = whois.User.Hostname;
userFromState.RealName = whois.User.RealName;
}, user, TaskContinuationOptions.OnlyOnRanToCompletion);
}
}
public AutoVoiceUser(IrcUser user, IrcChannel channel)
{
User = user;
Channel = channel;
_voiceTimer.Elapsed += delegate
{
if (!user.Modes.Contains("v"))
{
user.IrcClient.CommandHandler.Mode(Channel, "+v", User);
}
_voiceTimer.Stop();
};
_voiceTimer.Start();
}
private static void WhoIsChannel(IrcChannel channel, IrcClient client, int index)
{
// Note: joins and parts that happen during this will cause strange behavior here
Thread.Sleep(client.Settings.JoinWhoIsDelay * 1000);
var user = channel.Users[index];
client.WhoIs(user.Nick, (whois) =>
{
user.User = whois.User.User;
user.Hostname = whois.User.Hostname;
user.RealName = whois.User.RealName;
Task.Factory.StartNew(() => WhoIsChannel(channel, client, index + 1));
});
}
public static void HandleJoin(IrcClient client, IrcMessage message)
{
if (client.User.Nick == new IrcUser(message.Prefix).Nick)
{
// We've joined this channel
var channel = new IrcChannel(client, message.Parameters[0]);
client.Channels.Add(channel);
}
else
{
// Someone has joined a channel we're already in
client.Channels[message.Parameters[0]].Users.Add(new IrcUser(message.Prefix));
}
client.OnUserJoinedChannel(new ChannelUserEventArgs(client.Channels[message.Parameters[0]], new IrcUser(message.Prefix)));
}
public static void HandleGetTopic(IrcClient client, IrcMessage message)
{
IrcChannel channel = null;
string topic;
if(client.Channels.Contains(message.Parameters[1])) {
channel = client.Channels[message.Parameters[1]];
topic = message.Parameters[2];
channel.Topic = topic;
}
else {
channel = new IrcChannel(client, message.Parameters[1]);
topic = message.Parameters[2];
}
client.OnChannelTopicReceived(new ChannelTopicEventArgs(channel, topic));
}
public static void HandleJoin(IrcClient client, IrcMessage message)
{
// Quick hack fix for issue #2
if (message.Payload.StartsWith(":")) {
message.Payload = message.Payload.Substring(1);
}
if (client.User.Nick == new IrcUser(message.Prefix).Nick)
{
// We've joined this channel
var channel = new IrcChannel(client, message.Payload);
client.Channels.Add(channel);
}
else
{
// Someone has joined a channel we're already in
client.Channels[message.Payload].Users.Add(new IrcUser(message.Prefix));
}
client.OnUserJoinedChannel(new ChannelUserEventArgs(client.Channels[message.Payload], new IrcUser(message.Prefix)));
}
private void AddChannelExecuted(object sender, ExecutedRoutedEventArgs e)
{
var txtChannel = (TextBox)((Grid)sender).FindName("txtChannel");
if (!String.IsNullOrEmpty(txtChannel.Text))
{
var startChars = new char[] { '&', '#', '!', '+' };
var serverCoversation = ((UIServerConversation)e.Parameter);
var name = txtChannel.Text;
if (!startChars.Contains(name[0]))
{
name = '#' + name;
}
var channel = new IrcChannel(serverCoversation.Session, name, String.Empty);
if (serverCoversation.Session.Channels.Where(c => c.Name == name).Count() > 0)
{
channel = serverCoversation.Session.Channels.Where(c => c.Name == name).First();
}
serverCoversation.AddChannelConversation(channel);
}
}
public void Mode(IrcChannel Channel, string flags, params object[] Targets)
{
ircClient.Send("MODE " + Channel.Name + " " + flags + " " + Util.GetWords(Targets, 0));
}
public void Mode(IrcChannel Channel, string flags, string Targets)
{
ircClient.Send("MODE " + Channel.Name + " " + flags + " " + Targets);
}
protected abstract void OnChannelUserLeft(IrcChannel channel, IrcChannelUserEventArgs e);
protected abstract void OnChannelNoticeReceived(IrcChannel channel, IrcMessageEventArgs e);
public void Unban(IrcChannel Channel, params string[] Masks)
{
Unban(Channel.Name, Masks);
}
public void Invite(string Nick, IrcChannel Channel)
{
ircClient.Send("INVITE " + Nick + " " + Channel);
}
public void Ban(IrcChannel Channel, params object[] Masks)
{
Ban(Channel.Name, Masks);
}
protected virtual void OnChannelUserLeft(IrcChannel channel, IrcChannelUserEventArgs e)
{
}
public ChannelEventArgs(IrcChannel channel)
{
Channel = channel;
}
public void Part(IrcChannel chan, string reason, params object[] args)
{
ircClient.Send("PART " + chan.Name + " :" + String.Format(reason, args));
}
public void Invite(IrcUser User, IrcChannel Channel)
{
ircClient.Send("INVITE " + User + " " + Channel);
}
public void Unban(IrcChannel Channel, string Masks)
{
Unban(Channel, Masks.Split(' '));
}
public void Kick(IrcChannel channel, IrcUser user)
{
Kick(channel.Name, user.Nick);
}
public ChannelUserEventArgs(IrcChannel channel, IrcUser user)
{
Channel = channel;
User = user;
}
public void Kick(IrcChannel Channel, IrcUser User, string reasonFormat, params object[] args)
{
Kick(Channel.Name, User.Nick, reasonFormat, args);
}
protected abstract void OnChannelUserJoined(IrcChannel channel, IrcChannelUserEventArgs e);
public void KickBan(IrcChannel channel, string reason, params object[] masks)
{
Ban(channel, masks);
foreach (string mask in masks)
{
foreach (IrcUser u in channel)
if (u.Matches(mask))
Kick(channel, u, reason);
}
}
private static void WhoIsChannel(IrcChannel channel, IrcClient client, int index)
{
// Note: joins and parts that happen during this will cause strange behavior here
Thread.Sleep(client.Settings.JoinWhoIsDelay * 1000);
var user = channel.Users[index];
client.WhoIs(user.Nick, (whois) =>
{
user.User = whois.User.User;
user.Hostname = whois.User.Hostname;
user.RealName = whois.User.RealName;
Task.Factory.StartNew(() => WhoIsChannel(channel, client, index + 1));
});
}
public void KickBan(IrcChannel channel, TimeSpan time, params object[] masks)
{
Ban(channel, time, masks);
foreach (string mask in masks)
{
foreach (IrcUser u in channel)
if (u.Matches(mask))
Kick(channel, u);
}
}
protected virtual void OnChannelNoticeReceived(IrcChannel channel, IrcMessageEventArgs e)
{
}
internal void ParseModes(IrcUser user, IrcChannel chan, string flags, string[] args)
{
bool add = true;
if (chan == null)
{
// User Modes
for (int i = 0; i < flags.Length; i++)
{
var c = Convert.ToString(flags[i]);
if (c == "+")
{
add = true;
continue;
}
else if (c == "-")
{
add = false;
continue;
}
if (add)
irc.Me.AddMode(c);
else
irc.Me.DeleteMode(c);
irc.UserModeChangedNotify();
}
return;
}
int n = 0;
for (int i = 0; i < flags.Length; i++)
{
// Chan Modes/Flags
var c = Convert.ToString(flags[i]);
if (c == "+")
{
add = true;
continue;
}
else if (c == "-")
{
add = false;
continue;
}
var arg = "";
if (irc.HasChanMode(c))
{
// channel modes
if (add)
{
if (c == "b" || c == "k" || c == "l")
arg = args[n++];
if (c == "b")
{
var entry = new BanEntry(arg, user.Nick, DateTime.Now);
if (!chan.BanMasks.ContainsKey(arg))
{
chan.BanMasks.Add(arg, entry);
}
}
else
{
chan.AddMode(c, arg);
}
irc.ModeAddedNotify(user, chan, c, arg);
}
else
{
if (c == "b")
{
arg = args[n++];
chan.BanMasks.Remove(arg);
}
else
{
chan.DeleteMode(c);
}
irc.ModeDeletedNotify(user, chan, c, arg);
}
}
else
{
// channel user flags
var priv = irc.GetPrivForFlag(flags[i]);
if (priv != Privilege.Regular)
{
arg = args[n++];
var targ = irc.GetOrCreateUser(arg);
if (add)
{
chan.AddFlag(priv, targ);
irc.FlagAddedNotify(user, chan, priv, targ);
}
else
{
chan.DeleteFlag(priv, targ);
irc.FlagDeletedNotify(user, chan, priv, targ);
}
}
}
}
}
public NoticeCmdTrigger(StringStream args, IrcUser user, IrcChannel chan)
: base(args, user, chan)
{
}
protected virtual void OnChannelUserJoined(IrcChannel channel, IrcChannelUserEventArgs e)
{
}