private void btnJoin_Click(object sender, EventArgs e)
{
if (txtUserName.Text.Trim() != "")
{
try
{
NewJoin += new UserJoined(Form1_NewJoin);
MessageSent += new UserSendMessage(Form1_MessageSent);
RemoveUser += new UserLeft(Form1_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
InstanceContext context = new InstanceContext(new Form1(txtUserName.Text.Trim()));
factory = new DuplexChannelFactory <IChatChannel>(context, "ChatEndPoint");
channel = factory.CreateChannel();
channel.Open();
channel.Join(this.userName);
gbChatWindow.Enabled = true;
gbUserInfo.Enabled = false;
this.AcceptButton = btnSend;
txtChatMessages.AppendText("******Welcome to Turn Shop Automobile Chat Application****\r\n");
txtSendMessage.Select();
txtSendMessage.Focus();
this.Text = "Chat Clent-" + txtUserName.Text;
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString(), "Error");
}
}
}
async Task IMultiplayerClient.UserJoined(MultiplayerRoomUser user)
{
if (Room == null)
{
return;
}
await PopulateUser(user).ConfigureAwait(false);
Scheduler.Add(() =>
{
if (Room == null)
{
return;
}
// for sanity, ensure that there can be no duplicate users in the room user list.
if (Room.Users.Any(existing => existing.UserID == user.UserID))
{
return;
}
Room.Users.Add(user);
addUserToAPIRoom(user);
UserJoined?.Invoke(user);
RoomUpdated?.Invoke();
});
}
public async Task OnUserJoined(SocketGuildUser user)
{
var method = new UserJoined(Client, Config);
await method.ProcessAsync(user).ConfigureAwait(false);
IncrementEventHandle("UserJoined");
}
private void Handler_UserJoined(object sender, ChatEventArgs <ChatUserJoinedRoomDto> e)
{
if (e.InnerMessage.RoomId == Id)
{
UserJoined?.Invoke(this, e);
}
}
/// <summary>
/// Constructs a new <see cref="BaseSocketClientAbstraction"/> around an existing <see cref="WebSocket.BaseSocketClient"/>.
/// </summary>
/// <param name="baseSocketClient">The value to use for <see cref="WebSocket.BaseSocketClient"/>.</param>
/// <exception cref="ArgumentNullException">Throws for <paramref name="baseSocketClient"/>.</exception>
protected BaseSocketClientAbstraction(BaseSocketClient baseSocketClient)
: base(baseSocketClient)
{
baseSocketClient.ChannelCreated += x => ChannelCreated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ChannelDestroyed += x => ChannelDestroyed?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ChannelUpdated += (x, y) => ChannelUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.CurrentUserUpdated += (x, y) => CurrentUserUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildAvailable += x => GuildAvailable?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildMembersDownloaded += x => GuildMembersDownloaded?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildMemberUpdated += (x, y) => GuildMemberUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildUnavailable += x => GuildUnavailable?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.GuildUpdated += (x, y) => GuildUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.JoinedGuild += x => JoinedGuild?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.LeftGuild += x => LeftGuild?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageReceived += x => MessageReceived?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageUpdated += (x, y, z) => MessageUpdated?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.MessageDeleted += (x, y) => MessageDeleted?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionAdded += (x, y, z) => ReactionAdded?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionRemoved += (x, y, z) => ReactionRemoved?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.ReactionsCleared += (x, y) => ReactionsCleared?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RecipientAdded += x => RecipientAdded?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RecipientRemoved += x => RecipientRemoved?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleCreated += x => RoleCreated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleDeleted += x => RoleDeleted?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.RoleUpdated += (x, y) => RoleUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserBanned += (x, y) => UserBanned?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserIsTyping += (x, y) => UserIsTyping?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserJoined += x => UserJoined?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserLeft += x => UserLeft?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserUnbanned += (x, y) => UserUnbanned?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserUpdated += (x, y) => UserUpdated?.InvokeAsync(x.Abstract(), y.Abstract()) ?? Task.CompletedTask;
baseSocketClient.UserVoiceStateUpdated += (x, y, z) => UserVoiceStateUpdated?.InvokeAsync(x.Abstract(), y.Abstract(), z.Abstract()) ?? Task.CompletedTask;
baseSocketClient.VoiceServerUpdated += x => VoiceServerUpdated?.InvokeAsync(x.Abstract()) ?? Task.CompletedTask;
}
void ReceiveJoin(IrcMessage message)
{
string user = message.ExtractUser();
users.Add(user);
UserJoined?.Invoke(this, user);
}
private async Task DiscordShardedClientOnUserJoined(SocketGuildUser arg)
{
if (UserJoined != null)
{
await UserJoined.Invoke(this, arg).ConfigureAwait(false);
}
}
private void Bt_LogIn_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtUserName.Text.Trim()))
{
try
{
NewJoin += new UserJoined(ChatClient_NewJoin);
MessageSent += new UserSendMessage(ChatClient_MessageSent);
RemoveUser += new UserLeft(ChatClient_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
InstanceContext context = new InstanceContext(new MainWindow(txtUserName.Text.Trim()));
factory = new DuplexChannelFactory <IChatChannel>(context, "ChatEndPoint");
channel = factory.CreateChannel();
IOnlineStatus status = channel.GetProperty <IOnlineStatus>();
status.Offline += new EventHandler(Offline);
status.Online += new EventHandler(Online);
channel.Open();
channel.Join(this.userName);
rtbMessages.AppendText("*****************************WEL-COME to Chat Application*****************************\r\n");
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
private void _ChatClient_UserJoined(object sender, ChatUserJoinedEventArgs e)
{
UserJoined?.Invoke(this, new ChatUserInfoEventArgs
{
ServiceName = "Twitch",
UserName = e.UserName
});
}
private void OnUserJoined(Session session, User newUser)
{
UserJoined.RaiseEvent(session, newUser);
if (IsLocalUser(newUser))
{
CurrentUserJoined.RaiseEvent(session);
}
}
public async Task OnUserJoined(SocketGuildUser user)
{
if (!CanProcessEvent("UserJoined"))
{
return;
}
var method = new UserJoined(Client, Config);
await method.ProcessAsync(user).ConfigureAwait(false);
EventPostProcess("UserJoined");
}
private void Socket_DataReceived(object sender, dynamic data)
{
var type = data.Value <string>("type");
switch (type)//todo more from https://api.slack.com/rtm
{
case "message":
case "message.channels":
case "message.groups":
case "message.im":
case "message.mpim":
MessageReceived?.Invoke(this, new MessageReceivedEventArgs(MakeMessageFromData(data)));
break;
case "reaction_added":
ReactionAdded?.Invoke(this, GetReactionAddedEventArgs(data));
break;
case "reaction_removed":
ReactionRemoved?.Invoke(this, GetReactionAddedEventArgs(data));
break;
case "star_added":
StarAdded?.Invoke(this, GetReactionAddedEventArgs(data));
break;
case "star_removed":
StarRemoved?.Invoke(this, GetReactionAddedEventArgs(data));
break;
case "pin_added":
PinAdded?.Invoke(this, GetReactionAddedEventArgs(data));
break;
case "pin_removed":
PinRemoved?.Invoke(this, GetReactionAddedEventArgs(data));
break;
case "team_join":
UserJoined?.Invoke(this, new UserDataReceivedEventArgs(Team.Users.FirstOrDefault(x => x.Id == data.Value <string>("user")), null, Team));
break;
case "user_typing":
UserTyping?.Invoke(this, new UserDataReceivedEventArgs(Team.Users.FirstOrDefault(x => x.Id == data.Value <string>("user")),
Team.Channels.FirstOrDefault(x => x.Id == data.Value <string>("channel")), Team));
break;
case "presence_change":
UserPresenceChanged?.Invoke(this, new UserPresenceChangeEventArgs(data.Value <string>("presence"),
Team.Users.FirstOrDefault(x => x.Id == data.Value <string>("user"))));
break;
}
}
public void AddUser(string sid, string name)
{
if (!joinedUsers.Any(x => x.Id == sid))
{
var user = new UserDetails
{
Id = sid,
Name = name
};
joinedUsers.Add(user);
UserJoined?.Invoke(user);
}
}
private void ProcessMessage(string msg)
{
// Logger.LogTrace("Processing message: " + msg);
Console.WriteLine("Processing message: " + msg);
var userName = "";
var message = "";
userName = TwitchChatClient.reUserName.Match(msg).Groups[1].Value;
if (userName == chatBotName)
{
return; // Exit and do not process if the bot posted this message
}
var badges = TwitchChatClient.reBadges.Match(msg).Groups[1].Value.Split(',');
if (!string.IsNullOrEmpty(userName) && msg.Contains($" JOIN #{chatChannelName}"))
{
UserJoined?.Invoke(this, new ChatUserJoinedEventArgs {
UserName = userName
});
Console.WriteLine($"***** UserName: {userName} *****");
}
//// Review messages sent to the channel
if (reChatMessage.IsMatch(msg))
{
message = TwitchChatClient.reChatMessage.Match(msg).Groups[1].Value;
Console.WriteLine($"Message received from '{userName}': {message}");
//Logger.LogTrace($"Message received from '{userName}': {message}");
NewMessage?.Invoke(this, new NewMessageEventArgs
{
UserName = userName,
Message = message,
Badges = badges
});
}
else if (reWhisperMessage.IsMatch(msg))
{
message = TwitchChatClient.reWhisperMessage.Match(msg).Groups[1].Value;
Console.WriteLine($"Whisper received from '{userName}': {message}");
//Logger.LogTrace($"Whisper received from '{userName}': {message}");
NewMessage?.Invoke(this, new NewMessageEventArgs
{
UserName = userName,
Message = message,
Badges = (badges ?? new string[] { })
});
}
}
void OnUserJoined(ChatChannel twitchchannel, string user)
{
try
{
UserJoined?.Invoke(this, new UserInformation
{
Service = Service,
Username = user
});
}
catch (Exception e)
{
Logger.Error(this, "Error triggering UserJoined event", e);
}
}
private void OnUserJoinedSession(Session session, User user)
{
if (!session.IsJoined())
{
return;
}
if (!CurrentUsers.Contains(user))
{
//Debug.LogFormat("User {0} joined current session.", user.GetName());
CurrentUsers.RemoveAll(x => x.GetID() == user.GetID()); // in case there was an old user with the same ID
CurrentUsers.Add(user);
UserJoined.RaiseEvent(user);
}
}
private void OnCurrentUserJoinedSession(Session joinedSession)
{
//Debug.LogFormat("Joining session {0}.", joinedSession.GetName());
// If joining a new session, any user in the previous session (if any) have left
ClearCurrentSession();
// Send a join event for every user currently in the session we joined
for (int i = 0; i < joinedSession.GetUserCount(); i++)
{
User user = joinedSession.GetUser(i);
CurrentUsers.Add(user);
UserJoined.RaiseEvent(user);
}
}
public User AddUser(string sid, string userName)
{
if (!_joinedUsersList.Any(item => item.Id == sid))
{
var user = new User
{
Id = sid,
Name = userName
};
_joinedUsersList.Add(user);
UserJoined?.Invoke(user);
return(user);
}
else
{
return(null);
}
}
private void btnLogin_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtUserName.Text.Trim()))
{
try
{
// Register an event
NewJoin += new UserJoined(ChatClient_NewJoin);
MessageSent += new UserSendMessage
(ChatClient_MessageSent);
RemoveUser += new UserLeft(ChatClient_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
// Create InstanceContext to handle call back interface
// Pass the object of the CallbackContract implementor
InstanceContext context = new InstanceContext(
new ChatClient(txtUserName.Text.Trim()));
// We create a participant with the given end point
// The communication is managed with CHAT MESH and
// each client creates a duplex
// end point with the mesh. Mesh is nothing but the
// named collection of nodes.
factory =
new DuplexChannelFactory <IChatChannel>(context, "ChatEndPoint");
channel = factory.CreateChannel();
channel.Open();
channel.Join(this.userName);
grpMessageWindow.Enabled = true;
grpUserList.Enabled = true;
grpUserCredentials.Enabled = false;
this.AcceptButton = btnSend;
rtbMessages.AppendText
("****WEL-COME to Chat Application*****\r\n");
txtSendMessage.Select();
txtSendMessage.Focus();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
public async Task Join(UserJoined @event)
{
await this._unitOfWork.GetRepositoryAsync <PlatformUserJoinedCourseEntity>()
.AddAsync(new PlatformUserJoinedCourseEntity
{
CourseId = @event.CourseId,
PlatUserId = @event.PlatUserId,
UserId = @event.UserId
});
await this._unitOfWork.GetRepositoryAsync <PlatformUserEntity>()
.UpdateBach(u => u.UserId == @event.CreatorId, u => new PlatformUserEntity
{
UpdateTime = DateTime.Now,
StdJoined = u.StdJoined + 1
});
this._unitOfWork.SaveChanges();
}
private void ProcessMessage(string msg)
{
// Logger.LogTrace("Processing message: " + msg);
var userName = "";
var message = "";
userName = ChatClient.reUserName.Match(msg).Groups[1].Value;
if (!string.IsNullOrEmpty(userName) && msg.Contains($" JOIN #{ChannelName}"))
{
UserJoined?.Invoke(this, new ChatUserJoinedEventArgs {
UserName = userName
});
}
// Review messages sent to the channel
if (reChatMessage.IsMatch(msg))
{
message = ChatClient.reChatMessage.Match(msg).Groups[1].Value;
Logger.LogTrace($"Message received from '{userName}': {message}");
NewMessage?.Invoke(this, new NewMessageEventArgs
{
UserName = userName,
Message = message
});
}
else if (reWhisperMessage.IsMatch(msg))
{
message = ChatClient.reWhisperMessage.Match(msg).Groups[1].Value;
Logger.LogTrace($"Whisper received from '{userName}': {message}");
NewMessage?.Invoke(this, new NewMessageEventArgs
{
UserName = userName,
Message = message,
IsWhisper = true
});
}
}
private void OnUserJoinedSession(Session session, User user)
{
if (!session.IsJoined())
{
return;
}
if (!CurrentUsers.Contains(user))
{
// Remove any old users with the same ID
for (int i = CurrentUsers.Count - 1; i >= 0; i--)
{
if (CurrentUsers[i].GetID() == user.GetID())
{
CurrentUsers.RemoveAt(i);
}
}
CurrentUsers.Add(user);
UserJoined.RaiseEvent(user);
// Debug.LogFormat("User {0} joined current session.", user.GetName());
}
}
private void btnLogin_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtUserName.Text.Trim()))
{
try
{
NewJoin += new UserJoined(ChatClient_NewJoin);
MessageSent += new UserSendMessage(ChatClient_MessageSent);
RemoveUser += new UserLeft(ChatClient_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
InstanceContext context = new InstanceContext(
new ChatClient(txtUserName.Text.Trim()));
factory =
new DuplexChannelFactory<IChatChannel>(context, "ChatEndPoint");
channel = factory.CreateChannel();
IOnlineStatus status = channel.GetProperty<IOnlineStatus>();
status.Offline += new EventHandler(Offline);
status.Online += new EventHandler(Online);
channel.Open();
channel.Join(this.userName);
grpMessageWindow.Enabled = true;
grpUserList.Enabled = true;
grpUserCredentials.Enabled = false;
this.AcceptButton = btnSend;
rtbMessages.AppendText("*****************************WEL-COME to Chat Application*****************************\r\n");
txtSendMessage.Select();
txtSendMessage.Focus();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
protected virtual void OnUserJoined(string userName, string channel)
{
UserJoined?.Invoke(this, new UserJoinedEventArgs(userName, channel));
}
private void DataReceived(object o, MessageEventArgs e)
{
string originNick;
var commands = e.message.Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries);
// Servers like to send commands split in separate messages
if (lastMessage != null)
{
commands[0] = lastMessage + commands[0];
}
if (!e.message.EndsWith("\n"))
{
lastMessage = commands[commands.Length - 1];
commands = commands.Take(commands.Length - 1).ToArray();
}
else
{
lastMessage = null;
}
foreach (var command in commands)
{
Console.WriteLine(command);
var message = command.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
if (message[0].Contains('!'))
{
originNick = message[0].Substring(1, message[0].IndexOf('!') - 1);
}
else
{
originNick = message[0].Substring(1);
}
if (message.Length > 1)
{
if (message[0].Equals("PING"))
{
MsgPong(message[1]);
}
switch (message[1][0])
{
//Successful connection
case '0':
Connected?.Invoke(this, new EventArgs());
break;
//ERR message
case '4':
Error?.Invoke(this, new MessageEventArgs(command.Substring(command.LastIndexOf(':') + 1)));
break;
}
switch (message[1])
{
case "353":
AddUsers(command);
break;
//End of names list, guaranteed to get after joining channel
case "366":
JoinChannel(command);
break;
case "PART":
if (originNick.Equals(nick))
{
LeftChannel?.Invoke(this, new MessageEventArgs(command.Substring(command.IndexOf('#'))));
}
else
{
UserLeft?.Invoke(this, new ChannelEventArgs(command.Substring(command.IndexOf('#') + 1), originNick));
}
break;
case "JOIN":
if (originNick != nick)
{
UserJoined?.Invoke(this, new ChannelEventArgs(command.Substring(command.IndexOf('#')), originNick));
}
break;
case "PRIVMSG":
ReceivedMessage?.Invoke(this, new PrivateMessageEventArgs(message[2], originNick, command.Substring(1 + command.IndexOf(':', command.IndexOf("PRIVMSG")))));
break;
}
}
}
}
internal async Task OnUserJoined(SocketGuildUser user) => await(UserJoined?.Invoke(user) ?? Task.CompletedTask);
/// <summary>
/// Raises the <see cref="UserJoined"/> event.
/// </summary>
/// <param name="e">The <see cref="EventArgs"/> instance holding the event data.</param>
internal void OnUserJoined(IrcUserEventArgs e)
{
UserJoined?.Invoke(this, e);
}
protected void OnUserJoined(UserInfo userInfo, string channel)
{
UserJoined?.Invoke(userInfo, channel);
}
private void btnLogin_Click(object sender, EventArgs e)
{
if (!string.IsNullOrEmpty(txtUserName.Text.Trim()))
{
try
{
NewJoin += new UserJoined(ChatClient_NewJoin);
MessageSent += new UserSendMessage(ChatClient_MessageSent);
RemoveUser += new UserLeft(ChatClient_RemoveUser);
channel = null;
this.userName = txtUserName.Text.Trim();
/**/
#region IpAddress
string strHostName = System.Net.Dns.GetHostName();
string IPAddress = "";
IPHostEntry ipEntry = System.Net.Dns.GetHostEntry(strHostName);
foreach (IPAddress ipAddress in ipEntry.AddressList)
{
if (ipAddress.AddressFamily.ToString() == "InterNetwork")
{
IPAddress = ipAddress.ToString();
}
}
string Address = string.Format("net.tcp://{0}/ChatServer", IPAddress);
Uri URiAddress = new Uri(Address, UriKind.RelativeOrAbsolute);
#endregion
InstanceContext instanceContext = new InstanceContext(new ChatClient(txtUserName.Text.Trim()));
////NetPeerTcpBinding chatBinding = new NetPeerTcpBinding();
////Uri baseAddress = new Uri(Address);
////chatBinding.Port = 0;
////chatBinding.Security.Mode = SecurityMode.None;
////chatBinding.Resolver.Mode = PeerResolverMode.Custom;
////chatBinding.Resolver.Custom.Address = new EndpointAddress(baseAddress);
////chatBinding.Resolver.Custom.Binding = new NetTcpBinding(SecurityMode.None);
////chatBinding.Resolver.Custom.Binding.OpenTimeout = TimeSpan.FromMinutes(5);
////DuplexChannelFactory<IChatChannel> factory = new DuplexChannelFactory<IChatChannel>(instanceContext, chatBinding, "net.p2p://chatMesh/ChatServer");
////channel = factory.CreateChannel();
/**/
InstanceContext context = new InstanceContext(
new ChatClient(txtUserName.Text.Trim()));
factory =
new DuplexChannelFactory <IChatChannel>(context, "ChatEndPoint");
((System.ServiceModel.NetPeerTcpBinding)(((System.ServiceModel.ChannelFactory)(factory)).Endpoint.Binding)).Resolver.Custom.Address = new EndpointAddress(string.Format("net.tcp://{0}/ChatServer", IPAddress));
channel = factory.CreateChannel();
/**/
IOnlineStatus status = channel.GetProperty <IOnlineStatus>();
status.Offline += new EventHandler(Offline);
status.Online += new EventHandler(Online);
channel.Open();
channel.Join(this.userName);
grpMessageWindow.Enabled = true;
grpUserList.Enabled = true;
grpUserCredentials.Enabled = false;
this.AcceptButton = btnSend;
rtbMessages.AppendText("'''''''''''''''''''''WEL-COME to Chat Application''''''''''''''''''''''\r\n");
txtSendMessage.Select();
//txtSendMessage.Focus();
cmbProject.Focus();
CreateComponentTable();
}
catch (Exception ex)
{
MessageBox.Show(ex.ToString());
}
}
}
private void HandleUserData(string sender, string[] content, string data)
{
var username = sender.Substring(0, sender.IndexOf('!'));
if (!_cachedUsers.TryGetValue(username, out var user))
{
user = new User(this)
{
Username = username
};
_cachedUsers.TryAdd(username, user);
}
switch (content[0])
{
case "JOIN":
{
if (!_cachedChannels.TryGetValue(content[1], out var channel))
{
channel = new Channel(this)
{
Name = content[1]
};
_cachedChannels.TryAdd(content[1], channel);
Send($"MODE {channel.Name}");
Send($"NAMES {channel.Name}");
Send($"MODE {channel.Name} +b");
}
var channelUser = new ChannelUser(this, user, channel);
if (channel._users.All(x => x != user))
{
channel._users.Add(channelUser);
}
if (user._channels.All(x => x != channel))
{
user._channels.Add(channel);
}
UserJoined?.Invoke(new UserJoinedEventArgs
{
Client = this,
CurrentUser = CurrentUser,
Channel = channel,
User = channelUser
});
return;
}
case "PART":
{
var channelName = content[1];
if (channelName.StartsWith(':'))
{
channelName = channelName.Substring(1);
}
if (!_cachedChannels.TryGetValue(channelName, out var channel))
{
channel = new Channel(this)
{
Name = channelName
};
_cachedChannels.TryAdd(channelName, channel);
}
if (user._channels.Any(x => x == channel))
{
user._channels.Remove(channel);
}
if (channel._users.Any(x => x == user))
{
channel._users.RemoveAll(x => x == user);
}
UserLeft?.Invoke(new UserLeftEventArgs
{
Client = this,
CurrentUser = CurrentUser,
Channel = channel,
User = user,
Reason = content.Length > 2 ? data.Substring(data.IndexOf(':') + 1) : ""
});
return;
}
case "QUIT":
{
_cachedUsers.TryRemove(user.Username, out _);
foreach (var channel in _cachedChannels.Values)
{
channel._users.RemoveAll(x => x == user);
}
var reason = "";
var idof = data.IndexOf(':');
if (idof != -1)
{
reason = data.Substring(idof + 1);
}
UserQuit?.Invoke(new UserQuitEventArgs
{
Client = this,
CurrentUser = CurrentUser,
User = user,
Reason = reason
});
return;
}
case "NICK":
{
_cachedUsers.TryRemove(user.Username, out var oldUser);
user.Username = content[1].Substring(1);
_cachedUsers.TryRemove(user.Username, out _);
_cachedUsers.TryAdd(user.Username, user);
NicknameChanged?.Invoke(new NicknameChangedEventArgs
{
Client = this,
CurrentUser = CurrentUser,
User = user,
OldUsername = oldUser.Username,
NewUsername = user.Username
});
return;
}
case "PRIVMSG":
{
var cnt = data.Substring(1);
var message = cnt.Substring(cnt.IndexOf(':') + 1);
if (!user._channelMessages.TryGetValue(content[1], out var list))
{
list = new List <string> {
message
};
user._channelMessages.TryAdd(content[1], list);
}
else
{
list.Add(message);
}
if (content[1][0] == '#')
{
if (!_cachedChannels.TryGetValue(content[1], out var channel))
{
channel = new Channel(this)
{
Name = content[1]
};
_cachedChannels.TryAdd(content[1], channel);
}
channel._messages.Add((user, message));
MessageReceived?.Invoke(new MessageReceivedEventArgs
{
Client = this,
Channel = channel,
CurrentUser = CurrentUser,
Message = message,
User = channel.Users.FirstOrDefault(x => x == user) ?? user
});
return;
}
MessageReceived?.Invoke(new MessageReceivedEventArgs
{
Client = this,
Channel = null,
CurrentUser = CurrentUser,
Message = message,
User = user
});
return;
}
case "NOTICE":
{
var message = data.Substring(data.IndexOf(':') + 1);
if (!user._channelMessages.TryGetValue(content[1], out var list))
{
list = new List <string> {
message
};
user._channelMessages.TryAdd(content[1], list);
}
else
{
list.Add(message);
}
NoticeReceived?.Invoke(new NoticeReceivedEventArgs
{
Client = this,
CurrentUser = CurrentUser,
Message = message,
User = user
});
return;
}
case "MODE":
{
if (!_cachedChannels.TryGetValue(content[1], out var channel))
{
channel = new Channel(this)
{
Name = content[1]
};
_cachedChannels.TryAdd(content[1], channel);
}
var iofplus = content[2].IndexOf('+');
var iofminus = content[2].IndexOf('-');
var modesPlus = Array.Empty <char>();
var modesMinus = Array.Empty <char>();
if (iofplus != -1)
{
modesPlus = content[2].Substring(iofplus + 1).ToCharArray();
}
if (iofminus != -1)
{
modesMinus = iofplus != -1
? content[2].Substring(iofminus + 1, content[2].Length - iofplus - 1).ToCharArray()
: content[2].Substring(iofminus + 1).ToCharArray();
}
for (var i = 0; i < modesPlus.Length; i++)
{
if (!channel._modes.Contains(modesPlus[i]) && modesPlus[i] != 'b')
{
channel._modes.Add(modesPlus[i]);
}
}
for (var i = 0; i < modesMinus.Length; i++)
{
if (!channel._modes.Contains(modesMinus[i]) && modesMinus[i] != 'b')
{
channel._modes.Add(modesMinus[i]);
}
}
var complexModes = modesMinus.Where(x => _configuration.ComplexChanModes.Any(y => y == x && x != 'l')).ToList();
complexModes.AddRange(modesPlus.Where(x => _configuration.ComplexChanModes.Any(y => y == x)));
var extraArgs = content.Skip(3).ToList();
var modesArgs = new Dictionary <char, (char, string)>();
for (var i = 0; i < complexModes.Count && i < extraArgs.Count; i++)
{
modesArgs.Add(complexModes[i], (modesMinus.Contains(complexModes[i]) ? '-' : '+', extraArgs[i]));
}
foreach (var complexMod in modesArgs)
{
switch (complexMod.Key)
{
case 'b':
if (complexMod.Value.Item1 == '-')
{
channel._banList.RemoveWhere(x => x.Host == complexMod.Value.Item2);
}
else
{
channel._banList.Add(new ChannelBan
{
IssuedBy = user.Username,
Host = complexMod.Value.Item2,
IssuedOn = DateTimeOffset.UtcNow
});
}
break;
case 'l':
channel.Limit = int.Parse(complexMod.Value.Item2);
break;
case 'k':
channel.Key = complexMod.Value.Item1 == '+' ? complexMod.Value.Item2 : "";
break;
}
}
ChannelModeUpdated?.Invoke(new ChannelModesUpdatedEventArgs
{
Client = this,
CurrentUser = CurrentUser,
Channel = channel,
ModesAdded = new ReadOnlyCollection <char>(modesPlus),
ModesRemoved = new ReadOnlyCollection <char>(modesMinus),
ModesArgs = new ReadOnlyDictionary <char, (char, string)>(modesArgs),
User = channel.Users.FirstOrDefault(x => x == user)
});
return;
}
void OnChannelUserJoined(IChatChannel channel, UserInformation information)
{
UserJoined?.Invoke(information);
}
