Added several new events

Discord.Net/API/Models/General.cs

@@ -128,4 +128,14 @@ namespace Discord.API.Models
 		[JsonProperty(PropertyName = "channel_id")]
 		public string ChannelId;
 	}
+
+	internal class Role
+	{
+		[JsonProperty(PropertyName = "permissions")]
+		public int Permissions;
+		[JsonProperty(PropertyName = "name")]
+		public string Name;
+		[JsonProperty(PropertyName = "id")]
+		public string Id;
+	}
 }

Discord.Net/API/Models/WebSocketEvents.cs

@@ -30,19 +30,22 @@ namespace Discord.API.Models
 
 		internal sealed class ChannelCreate : ChannelInfo { }
 		internal sealed class ChannelDelete : ChannelInfo { }
+		internal sealed class ChannelUpdate : ChannelInfo { }
 
-		internal sealed class GuildMemberAdd
+		internal sealed class GuildMemberAdd : GuildMemberUpdate
+		{
+			[JsonProperty(PropertyName = "joined_at")]
+			public DateTime JoinedAt;
+		}
+		internal class GuildMemberUpdate
 		{
 			[JsonProperty(PropertyName = "user")]
 			public UserInfo User;
 			[JsonProperty(PropertyName = "roles")]
 			public object[] Roles;
-			[JsonProperty(PropertyName = "joined_at")]
-			public DateTime JoinedAt;
 			[JsonProperty(PropertyName = "guild_id")]
 			public string GuildId;
 		}
-
 		internal sealed class GuildMemberRemove
 		{
 			[JsonProperty(PropertyName = "user")]
@@ -50,6 +53,37 @@ namespace Discord.API.Models
 			[JsonProperty(PropertyName = "guild_id")]
 			public string GuildId;
 		}
+
+		internal sealed class GuildRoleCreateUpdate
+		{
+			[JsonProperty(PropertyName = "role")]
+			public Role Role;
+			[JsonProperty(PropertyName = "guild_id")]
+			public string GuildId;
+		}
+		internal sealed class GuildRoleDelete
+		{
+			[JsonProperty(PropertyName = "role_id")]
+			public string RoleId;
+			[JsonProperty(PropertyName = "guild_id")]
+			public string GuildId;
+		}
+
+		internal sealed class GuildBanAddRemove
+		{
+			[JsonProperty(PropertyName = "user")]
+			public UserInfo User;
+			[JsonProperty(PropertyName = "guild_id")]
+			public string GuildId;
+		}
+		internal sealed class GuildBanRemove
+		{
+			[JsonProperty(PropertyName = "user_id")]
+			public string UserId;
+			[JsonProperty(PropertyName = "guild_id")]
+			public string GuildId;
+		}
+
 		internal sealed class UserUpdate : SelfUserInfo { }
 		internal sealed class PresenceUpdate : PresenceUserInfo { }
 		internal sealed class VoiceStateUpdate

Discord.Net/Discord.Net.csproj

@@ -49,6 +49,7 @@
     <Compile Include="API\Models\ApiRequests.cs" />
     <Compile Include="API\Endpoints.cs" />
     <Compile Include="API\Models\WebSocketCommands.cs" />
+    <Compile Include="Models\Role.cs" />
     <Compile Include="Models\ChatMessageReference.cs" />
     <Compile Include="Models\ChatMessage.cs" />
     <Compile Include="Models\Channel.cs" />

Discord.Net/DiscordClient.Events.cs

@@ -5,46 +5,12 @@ namespace Discord
 {
 	public partial class DiscordClient
 	{
-		public sealed class ServerEventArgs : EventArgs
+		//Debug
-		{
-			public readonly Server Server;
-			internal ServerEventArgs(Server server) { Server = server; }
-		}
-		public sealed class ChannelEventArgs : EventArgs
-		{
-			public readonly Channel Channel;
-			internal ChannelEventArgs(Channel channel) { Channel = channel; }
-		}
-		public sealed class UserEventArgs : EventArgs
-		{
-			public readonly User User;
-			internal UserEventArgs(User user) { User = user; }
-		}
-		public sealed class MessageCreateEventArgs : EventArgs
-		{
-			public readonly ChatMessage Message;
-			internal MessageCreateEventArgs(ChatMessage msg) { Message = msg; }
-		}
-		public sealed class MessageEventArgs : EventArgs
-		{
-			public readonly ChatMessageReference Message;
-			internal MessageEventArgs(ChatMessageReference msg) { Message = msg; }
-		}
 		public sealed class LogMessageEventArgs : EventArgs
 		{
 			public readonly string Message;
 			internal LogMessageEventArgs(string msg) { Message = msg; }
 		}
-		public sealed class UserTypingEventArgs : EventArgs
-		{
-			public readonly User User;
-			public readonly Channel Channel;
-			internal UserTypingEventArgs(User user, Channel channel)
-			{
-				User = user;
-				Channel = channel;
-			}
-		}
 
 		public event EventHandler<LogMessageEventArgs> DebugMessage;
 		private void RaiseOnDebugMessage(string message)
@@ -53,6 +19,7 @@ namespace Discord
 				DebugMessage(this, new LogMessageEventArgs(message));
 		}
 
+		//General
 		public event EventHandler Connected;
 		private void RaiseConnected()
 		{
@@ -74,53 +41,201 @@ namespace Discord
 				LoggedIn(this, EventArgs.Empty);
 		}
 
-		public event EventHandler<ServerEventArgs> ServerCreated, ServerDestroyed;
+		//Server
+		public sealed class ServerEventArgs : EventArgs
+		{
+			public readonly Server Server;
+			internal ServerEventArgs(Server server) { Server = server; }
+		}
+
+		public event EventHandler<ServerEventArgs> ServerCreated;
 		private void RaiseServerCreated(Server server)
 		{
 			if (ServerCreated != null)
 				ServerCreated(this, new ServerEventArgs(server));
 		}
+
+		public event EventHandler<ServerEventArgs> ServerDestroyed;
 		private void RaiseServerDestroyed(Server server)
 		{
 			if (ServerDestroyed != null)
 				ServerDestroyed(this, new ServerEventArgs(server));
 		}
 
-		public event EventHandler<ChannelEventArgs> ChannelCreated, ChannelDestroyed;
+		//Channel
+		public sealed class ChannelEventArgs : EventArgs
+		{
+			public readonly Channel Channel;
+			internal ChannelEventArgs(Channel channel) { Channel = channel; }
+		}
+
+		public event EventHandler<ChannelEventArgs> ChannelCreated;
 		private void RaiseChannelCreated(Channel channel)
 		{
 			if (ChannelCreated != null)
 				ChannelCreated(this, new ChannelEventArgs(channel));
 		}
+
+		public event EventHandler<ChannelEventArgs> ChannelDestroyed;
 		private void RaiseChannelDestroyed(Channel channel)
 		{
 			if (ChannelDestroyed != null)
 				ChannelDestroyed(this, new ChannelEventArgs(channel));
 		}
 
+		public event EventHandler<ChannelEventArgs> ChannelUpdated;
+		private void RaiseChannelUpdated(Channel channel)
+		{
+			if (ChannelUpdated != null)
+				ChannelUpdated(this, new ChannelEventArgs(channel));
+		}
+
+		//User
+		public sealed class UserEventArgs : EventArgs
+		{
+			public readonly User User;
+			internal UserEventArgs(User user) { User = user; }
+		}
+
+		//Message
+		public sealed class MessageCreateEventArgs : EventArgs
+		{
+			public readonly ChatMessage Message;
+			internal MessageCreateEventArgs(ChatMessage msg) { Message = msg; }
+		}
+		public sealed class MessageEventArgs : EventArgs
+		{
+			public readonly ChatMessageReference Message;
+			internal MessageEventArgs(ChatMessageReference msg) { Message = msg; }
+		}
+
 		public event EventHandler<MessageCreateEventArgs> MessageCreated;
-		public event EventHandler<MessageEventArgs> MessageDeleted, MessageUpdated, MessageAcknowledged;
 		private void RaiseMessageCreated(ChatMessage msg)
 		{
 			if (MessageCreated != null)
 				MessageCreated(this, new MessageCreateEventArgs(msg));
 		}
+
+		public event EventHandler<MessageEventArgs> MessageDeleted;
 		private void RaiseMessageDeleted(ChatMessageReference msg)
 		{
 			if (MessageDeleted != null)
 				MessageDeleted(this, new MessageEventArgs(msg));
 		}
+
+		public event EventHandler<MessageEventArgs> MessageUpdated;
 		private void RaiseMessageUpdated(ChatMessageReference msg)
 		{
 			if (MessageUpdated != null)
 				MessageUpdated(this, new MessageEventArgs(msg));
 		}
+
+		public event EventHandler<MessageEventArgs> MessageAcknowledged;
 		private void RaiseMessageAcknowledged(ChatMessageReference msg)
 		{
 			if (MessageAcknowledged != null)
 				MessageAcknowledged(this, new MessageEventArgs(msg));
 		}
 
+		//Role
+		public sealed class RoleEventArgs : EventArgs
+		{
+			public readonly Role Role;
+			internal RoleEventArgs(Role role) { Role = role; }
+		}
+
+		public event EventHandler<RoleEventArgs> RoleCreated;
+		private void RaiseRoleCreated(Role role)
+		{
+			if (RoleCreated != null)
+				RoleCreated(this, new RoleEventArgs(role));
+		}
+
+		public event EventHandler<RoleEventArgs> RoleUpdated;
+		private void RaiseRoleDeleted(Role role)
+		{
+			if (RoleDeleted != null)
+				RoleDeleted(this, new RoleEventArgs(role));
+		}
+
+		public event EventHandler<RoleEventArgs> RoleDeleted;
+		private void RaiseRoleUpdated(Role role)
+		{
+			if (RoleUpdated != null)
+				RoleUpdated(this, new RoleEventArgs(role));
+		}
+
+		//Ban
+		public sealed class BanEventArgs : EventArgs
+		{
+			public readonly User User;
+			public readonly Server Server;
+			internal BanEventArgs(User user, Server server)
+			{
+				User = user;
+				Server = server;
+			}
+		}
+
+		public event EventHandler<BanEventArgs> BanAdded;
+		private void RaiseBanAdded(User user, Server server)
+		{
+			if (BanAdded != null)
+				BanAdded(this, new BanEventArgs(user, server));
+		}
+
+		public event EventHandler<BanEventArgs> BanRemoved;
+		private void RaiseBanRemoved(User user, Server server)
+		{
+			if (BanRemoved != null)
+				BanRemoved(this, new BanEventArgs(user, server));
+		}
+
+		//Member
+		public sealed class MemberEventArgs : EventArgs
+		{
+			public readonly User User;
+			public readonly Server Server;
+			internal MemberEventArgs(User user, Server server)
+			{
+				User = user;
+				Server = server;
+			}
+		}
+
+		public event EventHandler<MemberEventArgs> MemberAdded;
+		private void RaiseMemberAdded(User user, Server server)
+		{
+			if (MemberAdded != null)
+				MemberAdded(this, new MemberEventArgs(user, server));
+		}
+
+		public event EventHandler<MemberEventArgs> MemberRemoved;
+		private void RaiseMemberRemoved(User user, Server server)
+		{
+			if (MemberRemoved != null)
+				MemberRemoved(this, new MemberEventArgs(user, server));
+		}
+
+		public event EventHandler<MemberEventArgs> MemberUpdated;
+		private void RaiseMemberUpdated(User user, Server server)
+		{
+			if (MemberUpdated != null)
+				MemberUpdated(this, new MemberEventArgs(user, server));
+		}
+
+		//Status
+		public sealed class UserTypingEventArgs : EventArgs
+		{
+			public readonly User User;
+			public readonly Channel Channel;
+			internal UserTypingEventArgs(User user, Channel channel)
+			{
+				User = user;
+				Channel = channel;
+			}
+		}
+
 		public event EventHandler<UserEventArgs> PresenceUpdated;
 		private void RaisePresenceUpdated(User user)
 		{

Discord.Net/DiscordClient.cs

@@ -7,6 +7,7 @@ using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Reflection;
 using System.Threading.Tasks;
+using Role = Discord.Models.Role;
 
 namespace Discord
 {
@@ -107,15 +108,23 @@ namespace Discord
 							RaiseChannelDestroyed(channel);
 						}
 						break;
+					case "CHANNEL_UPDATE":
+						{
+							var data = e.Event.ToObject<WebSocketEvents.ChannelUpdate>();
+							var channel = DeleteChannel(data.Id);
+							RaiseChannelUpdated(channel);
+						}
+						break;
 
 					//Members
 					case "GUILD_MEMBER_ADD":
 						{
 							var data = e.Event.ToObject<WebSocketEvents.GuildMemberAdd>();
-                            var user = UpdateUser(data.User);
+							var user = UpdateUser(data.User);
 							var server = GetServer(data.GuildId);
 							server._members[user.Id] = true;
-                        }
+							RaiseMemberAdded(user, server);
+						}
 						break;
 					case "GUILD_MEMBER_REMOVE":
 						{
@@ -123,22 +132,56 @@ namespace Discord
 							var user = UpdateUser(data.User);
 							var server = GetServer(data.GuildId);
 							server._members[user.Id] = true;
+							RaiseMemberRemoved(user, server);
+						}
+						break;
+					case "GUILD_MEMBER_UPDATE":
+						{
+							var data = e.Event.ToObject<WebSocketEvents.GuildMemberUpdate>();
+							var user = UpdateUser(data.User);
+							var server = GetServer(data.GuildId);
+							RaiseMemberUpdated(user, server);
 						}
 						break;
 
-					//Users
+					//Roles
-					case "PRESENCE_UPDATE":
+					case "GUILD_ROLE_CREATE":
 						{
-							var data = e.Event.ToObject<WebSocketEvents.PresenceUpdate>();
+							var data = e.Event.ToObject<WebSocketEvents.GuildRoleCreateUpdate>();
-							var user = UpdateUser(data);
+							var role = UpdateRole(data);
-							RaisePresenceUpdated(user);
+							RaiseRoleCreated(role);
 						}
 						break;
-					case "VOICE_STATE_UPDATE":
+					case "GUILD_ROLE_DELETE":
 						{
-							var data = e.Event.ToObject<WebSocketEvents.VoiceStateUpdate>();
+							var data = e.Event.ToObject<WebSocketEvents.GuildRoleDelete>();
-							var user = GetUser(data.UserId); //TODO: Don't ignore this
+							var role = GetRole(data.RoleId, data.GuildId);
-							RaiseVoiceStateUpdated(user);
+							RaiseRoleDeleted(role);
+						}
+						break;
+					case "GUILD_ROLE_UPDATE":
+						{
+							var data = e.Event.ToObject<WebSocketEvents.GuildRoleCreateUpdate>();
+							var role = UpdateRole(data);
+							RaiseRoleUpdated(role);
+						}
+						break;
+
+					//Roles
+					case "GUILD_BAN_ADD":
+						{
+							var data = e.Event.ToObject<WebSocketEvents.GuildBanAddRemove>();
+							var user = UpdateUser(data.User);
+							var server = GetServer(data.GuildId);
+							RaiseBanAdded(user, server);
+						}
+						break;
+					case "GUILD_BAN_REMOVE":
+						{
+							var data = e.Event.ToObject<WebSocketEvents.GuildBanAddRemove>();
+							var user = UpdateUser(data.User);
+							var server = GetServer(data.GuildId);
+							RaiseBanRemoved(user, server);
 						}
 						break;
 
@@ -172,6 +215,22 @@ namespace Discord
 							RaiseMessageAcknowledged(msg);
 						}
 						break;
+
+					//Statuses
+					case "PRESENCE_UPDATE":
+						{
+							var data = e.Event.ToObject<WebSocketEvents.PresenceUpdate>();
+							var user = UpdateUser(data);
+							RaisePresenceUpdated(user);
+						}
+						break;
+					case "VOICE_STATE_UPDATE":
+						{
+							var data = e.Event.ToObject<WebSocketEvents.VoiceStateUpdate>();
+							var user = GetUser(data.UserId); //TODO: Don't ignore this
+							RaiseVoiceStateUpdated(user);
+						}
+						break;
 					case "TYPING_START":
 						{
 							var data = e.Event.ToObject<WebSocketEvents.TypingStart>();
@@ -271,7 +330,7 @@ namespace Discord
 			_users.TryGetValue(id, out user);
 			return user;
 		}
-		private User UpdateUser(UserInfo model)
+		private User UpdateUser(UserInfo model, bool addNew = true)
 		{
 			var user = GetUser(model.Id) ?? new User(model.Id, this);
 			
@@ -291,7 +350,8 @@ namespace Discord
 				user.Status = extendedModel.Status;
             }
 
-			_users[model.Id] = user;
+			if (addNew)
+				_users[model.Id] = user;
 			return user;
 		}
 
@@ -302,7 +362,7 @@ namespace Discord
 			_servers.TryGetValue(id, out server);
 			return server;
 		}
-		private Server UpdateServer(ServerInfo model)
+		private Server UpdateServer(ServerInfo model, bool addNew = true)
 		{
 			var server = GetServer(model.Id) ?? new Server(model.Id, this);
 			
@@ -321,17 +381,18 @@ namespace Discord
 
 				foreach (var channel in extendedModel.Channels)
 				{
-					UpdateChannel(channel, model.Id);
+					UpdateChannel(channel, model.Id, addNew);
 					server._channels[channel.Id] = true;
 				}
 				foreach (var membership in extendedModel.Members)
 				{
-					UpdateUser(membership.User);
+					UpdateUser(membership.User, addNew);
 					server._members[membership.User.Id] = true;
                 }
 			}
 
-			_servers[model.Id] = server;
+			if (addNew)
+				_servers[model.Id] = server;
 			return server;
 		}
 
@@ -342,7 +403,7 @@ namespace Discord
 			_channels.TryGetValue(id, out channel);
 			return channel;
 		}
-		private Channel UpdateChannel(ChannelInfo model, string serverId)
+		private Channel UpdateChannel(ChannelInfo model, string serverId, bool addNew = true)
 		{
 			var channel = GetChannel(model.Id) ?? new Channel(model.Id, serverId, this);
 
@@ -352,7 +413,8 @@ namespace Discord
 			channel.RecipientId = model.Recipient?.Id;
 			channel.Type = model.Type;
 
-			_channels[model.Id] = channel;
+			if (addNew)
+				_channels[model.Id] = channel;
 			return channel;
 		}
 		private Channel DeleteChannel(string id)
@@ -370,18 +432,13 @@ namespace Discord
 		private ChatMessageReference GetMessage(string id, string channelId)
 		{
 			if (id == null || channelId == null) return null;
-			var msg = new ChatMessageReference(id, this);
+			return new ChatMessageReference(id, channelId, this);
-
-			msg.ChannelId = channelId;
-
-			return msg;
 		}
-		private ChatMessage UpdateMessage(WebSocketEvents.MessageCreate model)
+		private ChatMessage UpdateMessage(WebSocketEvents.MessageCreate model, bool addNew = true)
 		{
-			return new ChatMessage(model.Id, this)
+			return new ChatMessage(model.Id, model.ChannelId, this)
 			{
 				Attachments = model.Attachments,
-				ChannelId = model.ChannelId,
 				Text = model.Content,
 				Embeds = model.Embeds,
 				IsMentioningEveryone = model.IsMentioningEveryone,
@@ -391,6 +448,20 @@ namespace Discord
 			};
 		}
 
+		private Role GetRole(string id, string serverId)
+		{
+			if (id == null || serverId == null) return null;
+			return new Role(id, serverId, this);
+		}
+		private Role UpdateRole(WebSocketEvents.GuildRoleCreateUpdate role, bool addNew = true)
+		{
+			return new Role(role.Role.Id, role.GuildId, this)
+			{
+				Name = role.Role.Name,
+				Permissions = role.Role.Permissions
+			};
+		}
+
 		private void CheckReady()
 		{
 			if (!_isReady)

Discord.Net/Models/Channel.cs

@@ -2,9 +2,9 @@
 
 namespace Discord.Models
 {
-	public class Channel
+	public sealed class Channel
 	{
-		protected readonly DiscordClient _client;
+		private readonly DiscordClient _client;
 		private string _name;
 
 		public string Id { get; }
@@ -13,7 +13,6 @@ namespace Discord.Models
 		public bool IsPrivate { get; internal set; }
 		public string Type { get; internal set; }
 		
-		[JsonIgnore]
 		public string ServerId { get; }
 		[JsonIgnore]
 		public Server Server { get { return ServerId != null ? _client.GetServer(ServerId) : null; } }
@@ -35,7 +34,6 @@ namespace Discord.Models
 		public override string ToString()
 		{
 			return Name;
-			//return Name + " (" + Id + ")";
 		}
 	}
 }

Discord.Net/Models/ChatMessage.cs

@@ -3,23 +3,23 @@ using System;
 
 namespace Discord.Models
 {
-	public class ChatMessage : ChatMessageReference
+	public sealed class ChatMessage : ChatMessageReference
 	{
 		public bool IsMentioningEveryone { get; internal set; }
 		public bool IsTTS { get; internal set; }
 		public string Text { get; internal set; }
 		public DateTime Timestamp { get; internal set; }
 		
-		[JsonIgnore]
 		public string UserId { get; internal set; }
+		[JsonIgnore]
 		public User User { get { return _client.GetUser(UserId); } }
 		
 		//Not Implemented
 		public object[] Attachments { get; internal set; }
 		public object[] Embeds { get; internal set; }
 
-		internal ChatMessage(string id, DiscordClient client)
+		internal ChatMessage(string id, string channelId, DiscordClient client)
-			: base(id, client)
+			: base(id, channelId, client)
 		{
 		}
 

Discord.Net/Models/ChatMessageReference.cs

@@ -1,16 +1,21 @@
-namespace Discord.Models
+using Newtonsoft.Json;
+
+namespace Discord.Models
 {
 	public class ChatMessageReference
 	{
 		protected readonly DiscordClient _client;
 
 		public string Id { get; }
-		public string ChannelId { get; internal set; }
+
+		public string ChannelId { get; }
+		[JsonIgnore]
 		public Channel Channel { get { return _client.GetChannel(ChannelId); } }
 
-		internal ChatMessageReference(string id, DiscordClient client)
+		internal ChatMessageReference(string id, string channelId, DiscordClient client)
 		{
 			Id = id;
+			ChannelId = channelId;
 			_client = client;
 		}
 	}

Discord.Net/Models/Role.cs

@@ -0,0 +1,29 @@
+using Newtonsoft.Json;
+
+namespace Discord.Models
+{
+	public sealed class Role
+	{
+		private readonly DiscordClient _client;
+
+		public string Id { get; }
+		public string Name { get; internal set; }
+
+		public int Permissions { get; internal set; }
+
+		public string ServerId { get; }
+		[JsonIgnore]
+		public Server Server { get { return _client.GetServer(ServerId); } }
+
+		internal Role(string id, string serverId, DiscordClient client)
+		{
+			Id = id;
+			_client = client;
+		}
+
+		public override string ToString()
+		{
+			return Name;
+		}
+	}
+}

Discord.Net/Models/Server.cs

@@ -6,9 +6,9 @@ using System.Linq;
 
 namespace Discord.Models
 {
-	public class Server
+	public sealed class Server
 	{
-		protected readonly DiscordClient _client;
+		private readonly DiscordClient _client;
 
 		public string Id { get; }
 		public string Name { get; internal set; }
@@ -22,13 +22,13 @@ namespace Discord.Models
 		public User Owner { get { return _client.GetUser(OwnerId); } }
 
 		internal ConcurrentDictionary<string, bool> _members;
-		[JsonIgnore]
 		public IEnumerable<string> MemberIds { get { return _members.Keys; } }
+		[JsonIgnore]
 		public IEnumerable<User> Members { get { return _members.Keys.Select(x => _client.GetUser(x)); } }
 
 		internal ConcurrentDictionary<string, bool> _channels;
-		[JsonIgnore]
 		public IEnumerable<string> ChannelIds { get { return _channels.Keys; } }
+		[JsonIgnore]
 		public IEnumerable<Channel> Channels { get { return _channels.Keys.Select(x => _client.GetChannel(x)); } }
 
 		//Not Implemented
@@ -47,7 +47,6 @@ namespace Discord.Models
 		public override string ToString()
 		{
 			return Name;
-			//return Name + " (" + Id + ")";
 		}
 	}
 }

Discord.Net/Models/User.cs

@@ -2,9 +2,9 @@
 
 namespace Discord.Models
 {
-	public class User
+	public sealed class User
 	{
-		protected readonly DiscordClient _client;
+		private readonly DiscordClient _client;
 
 		public string Id { get; }
 		public string Name { get; internal set; }
@@ -34,7 +34,6 @@ namespace Discord.Models
 		public override string ToString()
 		{
 			return Name;
-			//return Name + " (" + Id + ")";
 		}
 	}
 }