internal virtual async Task OnReceivedEvent(WebSocketEventEventArgs e)
{
try
{
switch (e.Type)
{
case "READY":
_userId = e.Payload["user"].Value <string>("id");
break;
case "VOICE_SERVER_UPDATE":
{
string guildId = e.Payload.Value <string>("guild_id");
if (_config.EnableVoice && guildId == _voiceSocket.CurrentServerId)
{
string token = e.Payload.Value <string>("token");
_voiceSocket.Host = "wss://" + e.Payload.Value <string>("endpoint").Split(':')[0];
await _voiceSocket.Login(_userId, _dataSocket.SessionId, token, _cancelToken).ConfigureAwait(false);
}
}
break;
}
}
catch (Exception ex)
{
RaiseOnLog(LogMessageSeverity.Error, LogMessageSource.Client, $"Error handling {e.Type} event: {ex.GetBaseException().Message}");
}
}
private async void OnReceivedEvent(WebSocketEventEventArgs e)
{
try
{
switch (e.Type)
{
case "VOICE_STATE_UPDATE":
{
var data = e.Payload.ToObject <VoiceStateUpdateEvent>(Serializer);
if (data.GuildId == VoiceSocket.Server?.Id && data.UserId == Service.Client.CurrentUser?.Id)
{
if (data.ChannelId == null)
{
await Disconnect().ConfigureAwait(false);
}
else
{
var channel = Service.Client.GetChannel(data.ChannelId.Value);
if (channel != null)
{
VoiceSocket.Channel = channel;
}
else
{
Logger.Warning("VOICE_STATE_UPDATE referenced an unknown channel, disconnecting.");
await Disconnect().ConfigureAwait(false);
}
}
}
}
break;
case "VOICE_SERVER_UPDATE":
{
var data = e.Payload.ToObject <VoiceServerUpdateEvent>(Serializer);
if (data.GuildId == VoiceSocket.Server?.Id)
{
var client = Service.Client;
var id = client.CurrentUser?.Id;
if (id != null)
{
var host = "wss://" + e.Payload.Value <string>("endpoint").Split(':')[0];
await VoiceSocket.Connect(host, data.Token, id.Value, GatewaySocket.SessionId, CancelToken).ConfigureAwait(false);
}
}
}
break;
}
}
catch (Exception ex)
{
Logger.Error($"Error handling {e.Type} event", ex);
}
}
internal override async Task OnReceivedEvent(WebSocketEventEventArgs e)
{
try
{
switch (e.Type)
{
//Global
case "READY": //Resync
{
base.OnReceivedEvent(e).Wait(); //This cannot be an await, or we'll get later messages before we're ready
var data = e.Payload.ToObject <ReadyEvent>(_serializer);
_currentUser = _users.GetOrAdd(data.User.Id, null);
_currentUser.Update(data.User);
foreach (var model in data.Guilds)
{
if (!model.Unavailable)
{
var server = _servers.GetOrAdd(model.Id);
server.Update(model);
}
}
foreach (var model in data.PrivateChannels)
{
var user = _users.GetOrAdd(model.Recipient.Id, null);
user.Update(model.Recipient);
var channel = _channels.GetOrAdd(model.Id, null, user.Id);
channel.Update(model);
}
}
break;
//Servers
case "GUILD_CREATE":
{
var data = e.Payload.ToObject <GuildCreateEvent>(_serializer);
if (!data.Unavailable)
{
var server = _servers.GetOrAdd(data.Id);
server.Update(data);
if (data.Unavailable == false)
{
RaiseServerAvailable(server);
}
else
{
RaiseServerCreated(server);
}
}
}
break;
case "GUILD_UPDATE":
{
var data = e.Payload.ToObject <GuildUpdateEvent>(_serializer);
var server = _servers[data.Id];
if (server != null)
{
server.Update(data);
RaiseServerUpdated(server);
}
}
break;
case "GUILD_DELETE":
{
var data = e.Payload.ToObject <GuildDeleteEvent>(_serializer);
var server = _servers.TryRemove(data.Id);
if (server != null)
{
if (data.Unavailable == true)
{
RaiseServerAvailable(server);
}
else
{
RaiseServerDestroyed(server);
}
}
}
break;
//Channels
case "CHANNEL_CREATE":
{
var data = e.Payload.ToObject <ChannelCreateEvent>(_serializer);
Channel channel;
if (data.IsPrivate)
{
var user = _users.GetOrAdd(data.Recipient.Id, null);
user.Update(data.Recipient);
channel = _channels.GetOrAdd(data.Id, null, user.Id);
}
else
{
channel = _channels.GetOrAdd(data.Id, data.GuildId, null);
}
channel.Update(data);
RaiseChannelCreated(channel);
}
break;
case "CHANNEL_UPDATE":
{
var data = e.Payload.ToObject <ChannelUpdateEvent>(_serializer);
var channel = _channels[data.Id];
if (channel != null)
{
channel.Update(data);
RaiseChannelUpdated(channel);
}
}
break;
case "CHANNEL_DELETE":
{
var data = e.Payload.ToObject <ChannelDeleteEvent>(_serializer);
var channel = _channels.TryRemove(data.Id);
if (channel != null)
{
RaiseChannelDestroyed(channel);
}
}
break;
//Members
case "GUILD_MEMBER_ADD":
{
var data = e.Payload.ToObject <MemberAddEvent>(_serializer);
var user = _users.GetOrAdd(data.User.Id, data.GuildId);
user.Update(data);
if (Config.TrackActivity)
{
user.UpdateActivity();
}
RaiseUserAdded(user);
}
break;
case "GUILD_MEMBER_UPDATE":
{
var data = e.Payload.ToObject <MemberUpdateEvent>(_serializer);
var user = _users[data.User.Id, data.GuildId];
if (user != null)
{
user.Update(data);
RaiseUserUpdated(user);
}
}
break;
case "GUILD_MEMBER_REMOVE":
{
var data = e.Payload.ToObject <MemberRemoveEvent>(_serializer);
var user = _users.TryRemove(data.UserId, data.GuildId);
if (user != null)
{
RaiseUserRemoved(user);
}
}
break;
case "GUILD_MEMBERS_CHUNK":
{
var data = e.Payload.ToObject <MembersChunkEvent>(_serializer);
foreach (var memberData in data.Members)
{
var user = _users.GetOrAdd(memberData.User.Id, memberData.GuildId);
user.Update(memberData);
//RaiseUserAdded(user);
}
}
break;
//Roles
case "GUILD_ROLE_CREATE":
{
var data = e.Payload.ToObject <RoleCreateEvent>(_serializer);
var role = _roles.GetOrAdd(data.Data.Id, data.GuildId);
role.Update(data.Data);
var server = _servers[data.GuildId];
if (server != null)
{
server.AddRole(role);
}
RaiseRoleUpdated(role);
}
break;
case "GUILD_ROLE_UPDATE":
{
var data = e.Payload.ToObject <RoleUpdateEvent>(_serializer);
var role = _roles[data.Data.Id];
if (role != null)
{
role.Update(data.Data);
RaiseRoleUpdated(role);
}
}
break;
case "GUILD_ROLE_DELETE":
{
var data = e.Payload.ToObject <RoleDeleteEvent>(_serializer);
var role = _roles.TryRemove(data.RoleId);
if (role != null)
{
RaiseRoleDeleted(role);
var server = _servers[data.GuildId];
if (server != null)
{
server.RemoveRole(role);
}
}
}
break;
//Bans
case "GUILD_BAN_ADD":
{
var data = e.Payload.ToObject <BanAddEvent>(_serializer);
var server = _servers[data.GuildId];
if (server != null)
{
server.AddBan(data.User?.Id);
RaiseUserBanned(data.User?.Id, server);
}
}
break;
case "GUILD_BAN_REMOVE":
{
var data = e.Payload.ToObject <BanRemoveEvent>(_serializer);
var server = _servers[data.GuildId];
if (server != null && server.RemoveBan(data.User?.Id))
{
RaiseUserUnbanned(data.User?.Id, server);
}
}
break;
//Messages
case "MESSAGE_CREATE":
{
var data = e.Payload.ToObject <MessageCreateEvent>(_serializer);
Message msg = null;
bool isAuthor = data.Author.Id == _userId;
if (msg == null)
{
msg = _messages.GetOrAdd(data.Id, data.ChannelId, data.Author.Id);
}
msg.Update(data);
if (Config.TrackActivity)
{
var channel = msg.Channel;
if (channel?.IsPrivate == false)
{
var user = msg.User;
if (user != null)
{
user.UpdateActivity(data.Timestamp);
}
}
}
RaiseMessageReceived(msg);
if (Config.AckMessages && !isAuthor)
{
await _api.AckMessage(data.Id, data.ChannelId).ConfigureAwait(false);
}
}
break;
case "MESSAGE_UPDATE":
{
var data = e.Payload.ToObject <MessageUpdateEvent>(_serializer);
var msg = _messages[data.Id];
if (msg != null)
{
msg.Update(data);
RaiseMessageUpdated(msg);
}
}
break;
case "MESSAGE_DELETE":
{
var data = e.Payload.ToObject <MessageDeleteEvent>(_serializer);
var msg = _messages.TryRemove(data.Id);
if (msg != null)
{
RaiseMessageDeleted(msg);
}
}
break;
case "MESSAGE_ACK":
{
var data = e.Payload.ToObject <MessageAckEvent>(_serializer);
var msg = GetMessage(data.MessageId);
if (msg != null)
{
RaiseMessageReadRemotely(msg);
}
}
break;
//Statuses
case "PRESENCE_UPDATE":
{
var data = e.Payload.ToObject <PresenceUpdateEvent>(_serializer);
var user = _users.GetOrAdd(data.User.Id, data.GuildId);
if (user != null)
{
user.Update(data);
RaiseUserPresenceUpdated(user);
}
}
break;
case "TYPING_START":
{
var data = e.Payload.ToObject <TypingStartEvent>(_serializer);
var channel = _channels[data.ChannelId];
if (channel != null)
{
var user = _users[data.UserId, channel.Server?.Id];
if (user != null)
{
if (channel != null)
{
RaiseUserIsTyping(user, channel);
}
}
if (Config.TrackActivity)
{
if (!channel.IsPrivate)
{
if (user != null)
{
user.UpdateActivity();
}
}
}
}
}
break;
//Voice
case "VOICE_STATE_UPDATE":
{
var data = e.Payload.ToObject <MemberVoiceStateUpdateEvent>(_serializer);
var user = _users[data.UserId, data.GuildId];
if (user != null)
{
var voiceChannel = user.VoiceChannel;
if (voiceChannel != null && data.ChannelId != voiceChannel.Id && user.IsSpeaking)
{
user.IsSpeaking = false;
RaiseUserIsSpeaking(user, _channels[voiceChannel.Id], false);
}
user.Update(data);
RaiseUserVoiceStateUpdated(user);
}
}
break;
//Settings
case "USER_UPDATE":
{
var data = e.Payload.ToObject <UserUpdateEvent>(_serializer);
var user = _globalUsers[data.Id];
if (user != null)
{
user.Update(data);
RaiseProfileUpdated();
}
}
break;
//Ignored
case "USER_SETTINGS_UPDATE":
case "GUILD_INTEGRATIONS_UPDATE":
break;
//Internal (handled in DataWebSocket)
case "RESUMED":
break;
//Pass to DiscordWSClient
case "VOICE_SERVER_UPDATE":
await base.OnReceivedEvent(e).ConfigureAwait(false);
break;
//Others
default:
RaiseOnLog(LogMessageSeverity.Warning, LogMessageSource.DataWebSocket, $"Unknown message type: {e.Type}");
break;
}
}
catch (Exception ex)
{
RaiseOnLog(LogMessageSeverity.Error, LogMessageSource.Client, $"Error handling {e.Type} event: {ex.GetBaseException().Message}");
}
}
private void OnReceivedEvent(WebSocketEventEventArgs e)
{
try
{
switch (e.Type)
{
//Global
case "READY":
{
//TODO: None of this is really threadsafe - should only replace the cache collections when they have been fully populated
var data = e.Payload.ToObject <ReadyEvent>(Serializer);
int channelCount = 0;
for (int i = 0; i < data.Guilds.Length; i++)
{
channelCount += data.Guilds[i].Channels.Length;
}
//ConcurrencyLevel = 2 (only REST and WebSocket can add/remove)
_servers = new ConcurrentDictionary <ulong, Server>(2, (int)(data.Guilds.Length * 1.05));
_channels = new ConcurrentDictionary <ulong, IChannel>(2, (int)(channelCount * 1.05));
_privateChannels = new ConcurrentDictionary <ulong, PrivateChannel>(2, (int)(data.PrivateChannels.Length * 1.05));
List <ulong> largeServers = new List <ulong>();
SessionId = data.SessionId;
PrivateUser = new User(data.User, this, null);
PrivateUser.Update(data.User);
CurrentUser = new Profile(data.User, this);
CurrentUser.Update(data.User);
for (int i = 0; i < data.Guilds.Length; i++)
{
var model = data.Guilds[i];
if (model.Unavailable != true)
{
var server = AddServer(model.Id);
server.Update(model);
if (model.IsLarge)
{
largeServers.Add(server.Id);
}
}
}
for (int i = 0; i < data.PrivateChannels.Length; i++)
{
AddPrivateChannel(data.PrivateChannels[i]);
}
if (largeServers.Count > 0)
{
GatewaySocket.SendRequestMembers(largeServers, "", 0);
}
else
{
EndConnect();
}
}
break;
//Servers
case "GUILD_CREATE":
{
var data = e.Payload.ToObject <GuildCreateEvent>(Serializer);
if (data.Unavailable != true)
{
var server = AddServer(data.Id);
server.Update(data);
if (data.Unavailable != false)
{
Logger.Info($"GUILD_CREATE: {server}");
}
else
{
Logger.Info($"GUILD_AVAILABLE: {server}");
}
if (data.Unavailable != false)
{
OnJoinedServer(server);
}
OnServerAvailable(server);
}
}
break;
case "GUILD_UPDATE":
{
var data = e.Payload.ToObject <GuildUpdateEvent>(Serializer);
var server = GetServer(data.Id);
if (server != null)
{
var before = Config.EnablePreUpdateEvents ? server.Clone() : null;
server.Update(data);
Logger.Info($"GUILD_UPDATE: {server}");
OnServerUpdated(before, server);
}
else
{
Logger.Warning("GUILD_UPDATE referenced an unknown guild.");
}
}
break;
case "GUILD_DELETE":
{
var data = e.Payload.ToObject <GuildDeleteEvent>(Serializer);
Server server = RemoveServer(data.Id);
if (server != null)
{
if (data.Unavailable != true)
{
Logger.Info($"GUILD_DELETE: {server}");
}
else
{
Logger.Info($"GUILD_UNAVAILABLE: {server}");
}
OnServerUnavailable(server);
if (data.Unavailable != true)
{
OnLeftServer(server);
}
}
else
{
Logger.Warning("GUILD_DELETE referenced an unknown guild.");
}
}
break;
//Channels
case "CHANNEL_CREATE":
{
var data = e.Payload.ToObject <ChannelCreateEvent>(Serializer);
IChannel channel = null;
if (data.GuildId != null)
{
var server = GetServer(data.GuildId.Value);
if (server != null)
{
channel = server.AddChannel(data, true);
}
else
{
Logger.Warning("CHANNEL_CREATE referenced an unknown guild.");
break;
}
}
else
{
channel = AddPrivateChannel(data);
}
Logger.Info($"CHANNEL_CREATE: {channel}");
OnChannelCreated(channel);
}
break;
case "CHANNEL_UPDATE":
{
var data = e.Payload.ToObject <ChannelUpdateEvent>(Serializer);
var channel = GetChannel(data.Id);
if (channel != null)
{
var before = Config.EnablePreUpdateEvents ? (channel as Channel).Clone() : null;
(channel as Channel).Update(data);
Logger.Info($"CHANNEL_UPDATE: {channel}");
OnChannelUpdated(before, channel);
}
else
{
Logger.Warning("CHANNEL_UPDATE referenced an unknown channel.");
}
}
break;
case "CHANNEL_DELETE":
{
var data = e.Payload.ToObject <ChannelDeleteEvent>(Serializer);
var channel = RemoveChannel(data.Id);
if (channel != null)
{
Logger.Info($"CHANNEL_DELETE: {channel}");
OnChannelDestroyed(channel);
}
else
{
Logger.Warning("CHANNEL_DELETE referenced an unknown channel.");
}
}
break;
//Members
case "GUILD_MEMBER_ADD":
{
var data = e.Payload.ToObject <GuildMemberAddEvent>(Serializer);
var server = GetServer(data.GuildId.Value);
if (server != null)
{
var user = server.AddUser(data, true, true);
user.Update(data);
user.UpdateActivity();
Logger.Info($"GUILD_MEMBER_ADD: {user}");
OnUserJoined(user);
}
else
{
Logger.Warning("GUILD_MEMBER_ADD referenced an unknown guild.");
}
}
break;
case "GUILD_MEMBER_UPDATE":
{
var data = e.Payload.ToObject <GuildMemberUpdateEvent>(Serializer);
var server = GetServer(data.GuildId.Value);
if (server != null)
{
var user = server.GetUser(data.User.Id);
if (user != null)
{
var before = Config.EnablePreUpdateEvents ? user.Clone() : null;
user.Update(data);
Logger.Info($"GUILD_MEMBER_UPDATE: {user}");
OnUserUpdated(before, user);
}
else
{
Logger.Warning("GUILD_MEMBER_UPDATE referenced an unknown user.");
}
}
else
{
Logger.Warning("GUILD_MEMBER_UPDATE referenced an unknown guild.");
}
}
break;
case "GUILD_MEMBER_REMOVE":
{
var data = e.Payload.ToObject <GuildMemberRemoveEvent>(Serializer);
var server = GetServer(data.GuildId.Value);
if (server != null)
{
var user = server.RemoveUser(data.User.Id);
if (user != null)
{
Logger.Info($"GUILD_MEMBER_REMOVE: {user}");
OnUserLeft(user);
}
else
{
Logger.Warning("GUILD_MEMBER_REMOVE referenced an unknown user.");
}
}
else
{
Logger.Warning("GUILD_MEMBER_REMOVE referenced an unknown guild.");
}
}
break;
case "GUILD_MEMBERS_CHUNK":
{
var data = e.Payload.ToObject <GuildMembersChunkEvent>(Serializer);
var server = GetServer(data.GuildId);
if (server != null)
{
foreach (var memberData in data.Members)
{
var user = server.AddUser(memberData, true, false);
user.Update(memberData);
}
Logger.Verbose($"GUILD_MEMBERS_CHUNK: {data.Members.Length} users");
if (server.CurrentUserCount >= server.UserCount) //Finished downloading for there
{
bool isConnectComplete = true;
foreach (var server2 in _servers.Select(x => x.Value))
{
if (server2.CurrentUserCount < server2.UserCount)
{
isConnectComplete = false;
}
}
if (isConnectComplete)
{
EndConnect();
}
}
}
else
{
Logger.Warning("GUILD_MEMBERS_CHUNK referenced an unknown guild.");
}
}
break;
//Roles
case "GUILD_ROLE_CREATE":
{
var data = e.Payload.ToObject <GuildRoleCreateEvent>(Serializer);
var server = GetServer(data.GuildId);
if (server != null)
{
var role = server.AddRole(data.Data.Id);
role.Update(data.Data, false);
Logger.Info($"GUILD_ROLE_CREATE: {role}");
OnRoleCreated(role);
}
else
{
Logger.Warning("GUILD_ROLE_CREATE referenced an unknown guild.");
}
}
break;
case "GUILD_ROLE_UPDATE":
{
var data = e.Payload.ToObject <GuildRoleUpdateEvent>(Serializer);
var server = GetServer(data.GuildId);
if (server != null)
{
var role = server.GetRole(data.Data.Id);
if (role != null)
{
var before = Config.EnablePreUpdateEvents ? role.Clone() : null;
role.Update(data.Data, true);
Logger.Info($"GUILD_ROLE_UPDATE: {role}");
OnRoleUpdated(before, role);
}
else
{
Logger.Warning("GUILD_ROLE_UPDATE referenced an unknown role.");
}
}
else
{
Logger.Warning("GUILD_ROLE_UPDATE referenced an unknown guild.");
}
}
break;
case "GUILD_ROLE_DELETE":
{
var data = e.Payload.ToObject <GuildRoleDeleteEvent>(Serializer);
var server = GetServer(data.GuildId);
if (server != null)
{
var role = server.RemoveRole(data.RoleId);
if (role != null)
{
Logger.Info($"GUILD_ROLE_DELETE: {role}");
OnRoleDeleted(role);
}
else
{
Logger.Warning("GUILD_ROLE_DELETE referenced an unknown role.");
}
}
else
{
Logger.Warning("GUILD_ROLE_DELETE referenced an unknown guild.");
}
}
break;
//Bans
case "GUILD_BAN_ADD":
{
var data = e.Payload.ToObject <GuildBanAddEvent>(Serializer);
var server = GetServer(data.GuildId.Value);
if (server != null)
{
var user = server.GetUser(data.User.Id);
if (user != null)
{
Logger.Info($"GUILD_BAN_ADD: {user}");
OnUserBanned(user);
}
else
{
Logger.Warning("GUILD_BAN_ADD referenced an unknown user.");
}
}
else
{
Logger.Warning("GUILD_BAN_ADD referenced an unknown guild.");
}
}
break;
case "GUILD_BAN_REMOVE":
{
var data = e.Payload.ToObject <GuildBanRemoveEvent>(Serializer);
var server = GetServer(data.GuildId.Value);
if (server != null)
{
var user = new User(data.User, this, server);
user.Update(data.User);
Logger.Info($"GUILD_BAN_REMOVE: {user}");
OnUserUnbanned(user);
}
else
{
Logger.Warning("GUILD_BAN_REMOVE referenced an unknown guild.");
}
}
break;
//Messages
case "MESSAGE_CREATE":
{
var data = e.Payload.ToObject <MessageCreateEvent>(Serializer);
var channel = GetChannel(data.ChannelId) as ITextChannel;
if (channel != null)
{
var user = (channel as Channel).GetUser(data.Author.Id);
if (user != null)
{
Message msg = null;
msg = (channel as Channel).MessageManager.Add(data, user);
user.UpdateActivity();
Logger.Verbose($"MESSAGE_CREATE: {channel} ({user})");
OnMessageReceived(msg);
}
else
{
Logger.Warning("MESSAGE_CREATE referenced an unknown user.");
}
}
else
{
Logger.Warning("MESSAGE_CREATE referenced an unknown channel.");
}
}
break;
case "MESSAGE_UPDATE":
{
var data = e.Payload.ToObject <MessageUpdateEvent>(Serializer);
var channel = GetChannel(data.ChannelId) as ITextChannel;
if (channel != null)
{
var msg = (channel as Channel).MessageManager.Get(data.Id, data.Author?.Id);
var before = Config.EnablePreUpdateEvents ? msg.Clone() : null;
msg.Update(data);
Logger.Verbose($"MESSAGE_UPDATE: {channel} ({data.Author?.Username ?? "Unknown"})");
OnMessageUpdated(before, msg);
}
else
{
Logger.Warning("MESSAGE_UPDATE referenced an unknown channel.");
}
}
break;
case "MESSAGE_DELETE":
{
var data = e.Payload.ToObject <MessageDeleteEvent>(Serializer);
var channel = GetChannel(data.ChannelId) as ITextChannel;
if (channel != null)
{
var msg = (channel as Channel).MessageManager.Remove(data.Id);
Logger.Verbose($"MESSAGE_DELETE: {channel} ({msg.User?.Name ?? "Unknown"})");
OnMessageDeleted(msg);
}
else
{
Logger.Warning("MESSAGE_DELETE referenced an unknown channel.");
}
}
break;
//Statuses
case "PRESENCE_UPDATE":
{
var data = e.Payload.ToObject <PresenceUpdateEvent>(Serializer);
User user;
Server server;
if (data.GuildId == null)
{
server = null;
user = GetPrivateChannel(data.User.Id)?.Recipient;
}
else
{
server = GetServer(data.GuildId.Value);
if (server == null)
{
Logger.Warning("PRESENCE_UPDATE referenced an unknown server.");
break;
}
else
{
user = server.GetUser(data.User.Id);
}
}
if (user != null)
{
if (Config.LogLevel == LogSeverity.Debug)
{
Logger.Debug($"PRESENCE_UPDATE: {user}");
}
var before = Config.EnablePreUpdateEvents ? user.Clone() : null;
user.Update(data);
OnUserUpdated(before, user);
}
/*else //Occurs when a user leaves a server
* Logger.Warning("PRESENCE_UPDATE referenced an unknown user.");*/
}
break;
case "TYPING_START":
{
var data = e.Payload.ToObject <TypingStartEvent>(Serializer);
var channel = GetChannel(data.ChannelId) as ITextChannel;
if (channel != null)
{
User user = (channel as Channel).GetUser(data.UserId);
if (user != null)
{
if (Config.LogLevel == LogSeverity.Debug)
{
Logger.Debug($"TYPING_START: {user.ToString(channel)}");
}
OnUserIsTypingUpdated(channel, user);
user.UpdateActivity();
}
}
}
break;
//Voice
case "VOICE_STATE_UPDATE":
{
var data = e.Payload.ToObject <VoiceStateUpdateEvent>(Serializer);
var server = GetServer(data.GuildId);
if (server != null)
{
var user = server.GetUser(data.UserId);
if (user != null)
{
if (Config.LogLevel == LogSeverity.Debug)
{
Logger.Debug($"VOICE_STATE_UPDATE: {user}");
}
var before = Config.EnablePreUpdateEvents ? user.Clone() : null;
user.Update(data);
//Logger.Verbose($"Voice Updated: {server.Name}/{user.Name}");
OnUserUpdated(before, user);
}
/*else //Occurs when a user leaves a server
* Logger.Warning("VOICE_STATE_UPDATE referenced an unknown user.");*/
}
else
{
Logger.Warning("VOICE_STATE_UPDATE referenced an unknown server.");
}
}
break;
//Settings
case "USER_UPDATE":
{
var data = e.Payload.ToObject <UserUpdateEvent>(Serializer);
if (data.Id == CurrentUser.Id)
{
var before = Config.EnablePreUpdateEvents ? CurrentUser.Clone() : null;
CurrentUser.Update(data);
PrivateUser.Update(data);
foreach (var server in _servers)
{
server.Value.CurrentUser.Update(data);
}
Logger.Info($"USER_UPDATE");
OnProfileUpdated(before, CurrentUser);
}
}
break;
//Handled in GatewaySocket
case "RESUMED":
break;
//Ignored
case "USER_SETTINGS_UPDATE":
case "GUILD_INTEGRATIONS_UPDATE":
case "VOICE_SERVER_UPDATE":
case "GUILD_EMOJIS_UPDATE":
case "MESSAGE_ACK":
Logger.Debug($"{e.Type} [Ignored]");
break;
//Others
default:
Logger.Warning($"Unknown message type: {e.Type}");
break;
}
}
catch (Exception ex)
{
Logger.Error($"Error handling {e.Type} event", ex);
}
}
