public async Task RemoveTeam(string teamName)
{
if (!IsApprovedAdmin)
{
return;
}
var file = Constants.ConfigRootDirectory + Constants.GuildDirectory + Context.Guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (server.TwitchTeams == null)
{
return;
}
if (server.TwitchTeams.Contains(teamName, StringComparer.CurrentCultureIgnoreCase))
{
var team = await _twitchManager.GetTwitchTeamByName(teamName);
server.TwitchTeams.Remove(teamName);
await BotFiles.SaveDiscordServer(server, Context.Guild);
await Context.Channel.SendMessageAsync("Removed " + team.DisplayName + " (" + teamName + ") from the server Twitch team list.");
}
else
{
await Context.Channel.SendMessageAsync("Token " + teamName + " isn't on the server Twitch team list.");
}
}
public async Task Remove(string channel)
{
if (!IsApprovedAdmin)
{
return;
}
var file = Constants.ConfigRootDirectory + Constants.GuildDirectory + Context.Guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (server.ServerBeamChannels == null)
{
return;
}
if (server.ServerBeamChannels.Contains(channel.ToLower()))
{
var beamChannel = await _mixerManager.GetChannelByName(channel);
server.ServerBeamChannels.Remove(channel.ToLower());
server.ServerBeamChannelIds.Remove(beamChannel.id.Value.ToString());
File.WriteAllText(file, JsonConvert.SerializeObject(server));
await Context.Channel.SendMessageAsync("Removed " + channel + " from the server Mixer streamer list.");
}
else
{
await Context.Channel.SendMessageAsync(channel + " wasn't on the server Mixer streamer list.");
}
}
public async Task Remove(string channel)
{
if (!IsApprovedAdmin)
{
return;
}
var file = Constants.ConfigRootDirectory + Constants.GuildDirectory + Context.Guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (server.ServerTwitchChannels == null)
{
return;
}
if (server.ServerTwitchChannels.Contains(channel.ToLower()))
{
var twitchId = await _twitchManager.GetTwitchIdByLogin(channel);
server.ServerTwitchChannels.Remove(channel.ToLower());
server.ServerTwitchChannelIds.Remove(twitchId);
await BotFiles.SaveDiscordServer(server, Context.Guild);
await Context.Channel.SendMessageAsync("Removed " + channel + " from the server Twitch streamer list.");
}
else
{
await Context.Channel.SendMessageAsync(channel + " wasn't on the server Twitch streamer list.");
}
}
public async Task RemoveGame(string gameName)
{
if (!IsApprovedAdmin)
{
return;
}
var file = Constants.ConfigRootDirectory + Constants.GuildDirectory + Context.Guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (server.ServerGameList == null)
{
return;
}
if (server.ServerGameList.Contains(gameName, StringComparer.CurrentCultureIgnoreCase))
{
server.ServerGameList.Remove(gameName);
await BotFiles.SaveDiscordServer(server, Context.Guild);
await Context.Channel.SendMessageAsync("Removed " + gameName + " from the server Twitch game list.");
}
else
{
await Context.Channel.SendMessageAsync(gameName + " isn't on the server Twitch game list.");
}
}
public async Task ListGames()
{
if (!IsApprovedAdmin)
{
return;
}
var file = Constants.ConfigRootDirectory + Constants.GuildDirectory + Context.Guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (server.ServerGameList == null)
{
server.ServerGameList = new List <string>();
}
var builder = new StringBuilder();
foreach (var tt in server.ServerGameList)
{
builder.Append(tt + ", ");
}
string info = "```Markdown\r\n" +
"# Server Twitch Games\r\n" +
builder.ToString().Trim().TrimEnd(',') + "\r\n" +
"```\r\n";
await Context.Channel.SendMessageAsync(info);
}
public async Task Remove(IGuildUser user)
{
var guild = ((IGuildUser)Context.Message.Author).Guild;
var authorUser = ((IGuildUser)Context.Message.Author);
if (!authorUser.GuildPermissions.ManageGuild)
{
return;
}
var file = _botSettings.DirectorySettings.ConfigRootDirectory + _botSettings.DirectorySettings.GuildDirectory + guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (server.ApprovedAdmins == null || !server.ApprovedAdmins.Contains(user.Id))
{
await Context.Channel.SendMessageAsync(user.Username + " is not on the approved admins list for this server.");
return;
}
server.ApprovedAdmins.Remove(user.Id);
await _fileService.SaveDiscordServer(server, Context.Guild);
await Context.Channel.SendMessageAsync(user.Username + " has been removed from the approved admin list for this server.");
}
public void InviteDeleted(DiscordServer server, DiscordInvite invite)
{
foreach (var e in this.invite)
{
e.InviteDeleted(server, invite);
}
}
public void OnServerRoleRemove(DiscordServer server, DiscordRole role)
{
foreach (var e in this.server)
{
e.OnServerRoleRemove(server, role);
}
}
public async Task Remove(string channel)
{
if (!IsApprovedAdmin)
{
return;
}
var file = _botSettings.DirectorySettings.ConfigRootDirectory + _botSettings.DirectorySettings.GuildDirectory + Context.Guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (server.PicartoChannels == null)
{
return;
}
if (server.PicartoChannels.Contains(channel.ToLower()))
{
server.PicartoChannels.Remove(channel.ToLower());
await _fileService.SaveDiscordServer(server, Context.Guild);
await Context.Channel.SendMessageAsync("Removed " + channel + " from the server Picarto streamer list.");
}
else
{
await Context.Channel.SendMessageAsync(channel + " wasn't on the server Picarto streamer list.");
}
}
/// <summary>
/// Makes a new instance of <see cref="BotChannel"/> class.
/// </summary>
public BotChannel(DiscordServer server)
{
_server = server;
_config = server.Configuration;
Drawables = new ConcurrentDictionary <int, DrawableSection>();
}
public void OnServerUnban(DiscordServer server, DiscordUser user)
{
foreach (var e in this.server)
{
e.OnServerUnban(server, user);
}
}
public async Task Remove(string name)
{
if (!IsApprovedAdmin)
{
return;
}
var id = await _vidMeManager.GetIdByName(name);
var file = Constants.ConfigRootDirectory + Constants.GuildDirectory + Context.Guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (server.ServerVidMeChannels == null)
{
return;
}
if (server.ServerVidMeChannels.Contains(name.ToLower()))
{
server.ServerVidMeChannels.Remove(name.ToLower());
server.ServerVidMeChannelIds.Remove(id);
File.WriteAllText(file, JsonConvert.SerializeObject(server));
await Context.Channel.SendMessageAsync("Removed " + name + " from the server Vid.me list.");
}
else
{
await Context.Channel.SendMessageAsync(name + " wasn't on the server Vid.me list.");
}
}
public async Task SetMuteRole(string parameter)
{
if (((SocketGuildUser)Context.User).GuildPermissions.Has(Discord.GuildPermission.ManageRoles))
{
DiscordServer server = DiscordServer.GetServerFromID(Context.Guild.Id);
if (server != null)
{
SocketRole FoundRole = null;
foreach (SocketRole role in Context.Guild.Roles)
{
if (role.Name == parameter)
{
FoundRole = role;
break;
}
}
if (FoundRole != null)
{
server.MuteRole = FoundRole;
server.SaveData();
await ReplyAsync("Mute Role set to: " + server.MuteRole.Name + "!");
}
else
{
await ReplyAsync("There is no role such as " + parameter);
}
}
}
else
{
await ReplyAsync("You dont have sufficient permissions to set the mute role!");
}
}
public void OnServerMemberLeft(DiscordServer server, DiscordServerMember member)
{
foreach (var e in this.server)
{
e.OnServerMemberLeft(server, member);
}
}
public void BeginVoiceConnect(Action <object> callback, string serverID, string channelID)
{
DiscordServer server = client.GetServersList().Find(x => x.id == serverID);
if (server != null)
{
DiscordChannel channel = server.channels.Find(x => x.ID == channelID);
if (channel != null)
{
if (channel.Type != ChannelType.Voice)
{
callback.Invoke(new { Message = "Not a voice channel!" });
return;
}
client.ConnectToVoiceChannel(channel);
client.VoiceClientConnected += (sender, e) =>
{
callback.Invoke(new { Message = "Connected!" });
};
}
else
{
callback.Invoke(new { Message = "Channel was null! ID: " + channelID });
}
}
else
{
callback.Invoke(new { Message = "Server was null! ID: " + serverID });
}
}
public async Task On()
{
var guild = ((IGuildUser)Context.Message.Author).Guild;
var user = ((IGuildUser)Context.Message.Author);
if (!user.GuildPermissions.ManageGuild)
{
return;
}
var file = _botSettings.DirectorySettings.ConfigRootDirectory + _botSettings.DirectorySettings.GuildDirectory + guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
server.Goodbyes = true;
if (string.IsNullOrEmpty(server.GoodbyeMessage))
{
server.GoodbyeMessage = "Good bye, %USER%, thanks for hanging out!";
}
await _fileService.SaveDiscordServer(server, Context.Guild);
await Context.Channel.SendMessageAsync("Goodbyes have been turned on.");
}
public void GetMemberByID(Action <object> callback, string serverID, string memberID)
{
DiscordServer server = client.GetServersList().Find(x => x.id == serverID);
if (server != null)
{
DiscordMember member = server.members.Find(x => x.ID == memberID);
if (member != null)
{
object memberCallback = new
{
MemberUsername = member.Username,
MemberAvatarURL = member.GetAvatarURL().ToString(),
MemberID = member.ID,
MemberDiscrim = member.Discriminator,
MemberStatus = member.Status,
MemberCurrentGame = member.CurrentGame
};
callback.Invoke(memberCallback);
}
else
{
object noMemberCallback = new { Message = $"Couldn't find member with ID {memberID} in server {serverID}!" };
callback.Invoke(noMemberCallback);
}
}
else
{
object noServerCallback = new { Message = "Couldn't find server given ID " + serverID };
callback.Invoke(noServerCallback);
}
}
/// <summary>
/// Retrieves a channel by its name in the given serverID.
/// </summary>
/// <param name="callback">The Javascript function callback.</param>
/// <param name="serverID">The ID of the server to look in.</param>
/// <param name="name">The name of the channel.</param>
/// <param name="voice">If true, only return voice channels.</param>
public void GetChannelByName(Action <object> callback, string serverID, string name, bool voice)
{
DiscordServer server = client.GetServersList().Find(x => x.id == serverID);
if (server != null)
{
DiscordChannel channel = null;
if (voice)
{
server.channels.Find(x => x.Name.ToLower() == name.ToLower().Trim('#') && x.Type == ChannelType.Voice);
}
else
{
server.channels.Find(x => x.Name.ToLower() == name.ToLower().Trim('#'));
}
if (channel != null)
{
object channelCallbackObject = new
{
ChannelName = channel.Name,
ChannelID = channel.ID,
ChannelTopic = channel.Topic
};
callback.Invoke(channelCallbackObject);
}
}
}
public async Task Points(string mention = "")
{
DiscordServer server = DiscordServer.GetServerFromID(Context.Guild.Id);
if (server != null)
{
ServerUser user = null;
if (Context.Message.MentionedUsers.Count > 0)
{
user = server.Users.Find(x => x.userID == Context.Message.MentionedUsers.ElementAt(0).Id);
}
else
{
user = server.Users.Find(x => x.userID == Context.User.Id);
}
if (user != null)
{
await ReplyAsync(Context.User.Mention + ". " + user.username + " have " + user.Points + " points!");
}
else
{
await ReplyAsync("Something went wrong!");
}
}
}
public void OnServerRoleUpdated(DiscordServer server, DiscordRole role)
{
foreach (var e in this.server)
{
e.OnServerRoleUpdated(server, role);
}
}
public async Task ResetServer()
{
IUserMessage message = await ReplyAsync("Reseting...");
DiscordServer server = DiscordServer.GetServerFromID(Context.Guild.Id);
if (server != null)
{
server.Users = new List <ServerUser>();
foreach (SocketGuildUser user in server.Guild.Users)
{
if (server.Users.Find(x => x.userID == user.Id) == null)
{
server.Users.Add(new ServerUser(user));
}
}
}
else
{
await message.ModifyAsync(x => x.Content = "I dont think i did it right.");
}
server.SaveData();
server.LoadData();
await message.ModifyAsync(x => x.Content = "L-Like this?");
}
public void OnServerMembersChunk(DiscordServer server, DiscordServerMember[] members, string[] notFound, DiscordPresence[] presences)
{
foreach (var e in this.server)
{
e.OnServerMembersChunk(server, members, notFound, presences);
}
}
public static DiscordServer GetDiscordServer(string guildId)
{
var file = Constants.ConfigRootDirectory + Constants.GuildDirectory + guildId + ".json";
var server = new DiscordServer();
return(server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file)));
}
public void OnServerEmojisUpdated(DiscordServer server, DiscordEmoji[] emojis)
{
foreach (var e in this.server)
{
e.OnServerEmojisUpdated(server, emojis);
}
}
public void RemoveLogChannelId(ulong guildId)
{
DiscordServer server = GetServer(guildId);
server.LogChannelId = 0;
SaveUsers();
}
public void OnServerUpdated(DiscordServer server)
{
foreach (var e in this.server)
{
e.OnServerUpdated(server);
}
}
public void SetLogChannelId(ulong guildId, ulong logchannelId)
{
DiscordServer server = GetServer(guildId);
server.LogChannelId = logchannelId;
SaveUsers();
}
public async Task TextAnnouncements(string trueFalse)
{
var guild = ((IGuildUser)Context.Message.Author).Guild;
var user = ((IGuildUser)Context.Message.Author);
if (!user.GuildPermissions.ManageGuild)
{
return;
}
trueFalse = trueFalse.ToLower();
if (!trueFalse.Equals("true") && !trueFalse.Equals("false"))
{
await Context.Channel.SendMessageAsync("Pass true or false when configuring Text Announcements. (ie: !cb config textannouncements true)");
return;
}
var file = _botSettings.DirectorySettings.ConfigRootDirectory + _botSettings.DirectorySettings.GuildDirectory + guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
server.UseTextAnnouncements = bool.Parse(trueFalse);
await _fileService.SaveDiscordServer(server, Context.Guild);
await Context.Channel.SendMessageAsync("Text announcements has been set to: " + trueFalse);
}
public void OnVoiceServerUpdated(DiscordServer server, string token, string endpoint)
{
foreach (var e in voice)
{
e.OnVoiceServerUpdated(server, token, endpoint);
}
}
public async Task MentionRole(IRole role)
{
var guild = ((IGuildUser)Context.Message.Author).Guild;
var user = ((IGuildUser)Context.Message.Author);
if (!user.GuildPermissions.ManageGuild)
{
return;
}
var file = _botSettings.DirectorySettings.ConfigRootDirectory + _botSettings.DirectorySettings.GuildDirectory + guild.Id + ".json";
var server = new DiscordServer();
if (File.Exists(file))
{
server = JsonConvert.DeserializeObject <DiscordServer>(File.ReadAllText(file));
}
if (role.Name.ToLower().Contains("everyone"))
{
server.MentionRole = 0;
}
else
{
server.MentionRole = role.Id;
}
await _fileService.SaveDiscordServer(server, Context.Guild);
await Context.Channel.SendMessageAsync("Mention Role has been set to: " + role.Name);
}
public ServerView(DiscordServer server)
{
InitializeComponent();
Server = server;
RefreshContent();
SetTheme();
}
public ServerView(DiscordServer server, DiscordClient client)
{
InitializeComponent();
mainClientReference = client;
Server = server;
RefreshContent();
SetTheme();
}
public ServerView(DiscordServer server)
{
InitializeComponent();
Server = server;
RefreshContent();
SetTheme();
AllowResizing = true;
}
public override void Install(CommandsManager manager)
{
/**
cool hack
*/
manager.Client.GuildUpdated += (sender, e) =>
{
Console.WriteLine($"[TestServerLog Module] Guild update. Old guild name: {e.OldServer.Name}");
if(DiscordSharpTestServer != null)
{
if (e.NewServer.ID == DiscordSharpTestServer.ID) //test server
{
Console.WriteLine($"[TestServerLog Module] Posting comparison.");
string msg = $"**Server Update**\n";
msg += $"\n**Name: **: {e.OldServer.Name} -> {e.NewServer.Name}";
msg += $"\n**Icon:** <{e.OldServer.IconURL}> -> <{e.OldServer.IconURL}>";
msg += $"\n**ID:** {e.NewServer.ID}";
msg += $"\n**Owner: ** {e.OldServer.Owner.ID} -> {e.NewServer.Owner.ID}";
msg += $"\n**Region: ** {e.OldServer.Region} -> {e.NewServer.Region}";
msg += $"\n**Users Online: **";
foreach (var user in DiscordSharpTestServer.Members)
{
if (user.Value != null && user.Value.Status == Status.Online)
msg += $"{user.Value.Username}, ";
}
msg += "\n------------------------------";
LogChannel.SendMessage(msg);
DiscordSharpTestServer = e.NewServer;
}
}
};
manager.Client.ChannelUpdated += (sender, e) =>
{
if (LogChannel != null && DiscordSharpTestServer != null)
{
if (e.NewChannel.Parent.ID == DiscordSharpTestServer.ID)
{
string msg = $"**Channel Update**\n";
msg += $"\n**Name: ** {e.OldChannel.Name} -> {e.NewChannel.Name}";
msg += $"\n**Topic:** {e.OldChannel.Topic} -> {e.NewChannel.Topic}";
msg += $"\n**ID:** {e.NewChannel.ID}";
msg += $"\n**Users Online: **";
foreach (var user in DiscordSharpTestServer.Members)
{
if (user.Value != null && user.Value.Status == Status.Online)
msg += $"{user.Value.Username}, ";
}
msg += "\n------------------------------";
LogChannel.SendMessage(msg);
}
}
};
}
public ServerStub(DiscordServer server)
{
Server = server;
InitializeComponent();
if (server.IconURL != null)
serverIcon.Source = new BitmapImage(new Uri(server.IconURL));
serverNameLabel.Content = server.name;
this.ToolTip = server.name;
SetupTheme();
}
public TestServerLog(DiscordClient client)
{
Name = "discordsharp-logs";
Description = "nunya";
DiscordSharpTestServer = client.GetServersList().Find(
x => x.Name == "DiscordSharp Test Server"
); //todo replace with id
if(DiscordSharpTestServer != null)
{
LogChannel = DiscordSharpTestServer.Channels.Find(x => x.Name == "log" && x.Type == ChannelType.Text);
}
}
public ServerInfo(DiscordServer server)
{
Server = server;
InitializeComponent();
Icon = new BitmapImage(new Uri(server.IconURL));
Title = $"Info for Server {Server.name}";
serverIcon.Source = Icon;
serverNameLabel.Content = Server.name;
owner.Content = $"Owner: {Server.owner.Username} ({Server.owner.ID})";
channelsNumeber.Content = $"Channels Count: {Server.channels.Count}";
membersNumber.Content = $"Members Count: {Server.members.Count}";
}
/// <summary>
/// Edits the name of the guild, given you have the permission.
/// </summary>
/// <param name="guild">The guild's name you wish to edit.</param>
/// <param name="NewGuildName">The new guild name.</param>
public void EditGuildName(DiscordServer guild, string NewGuildName)
{
string editGuildUrl = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}";
var newNameJson = JsonConvert.SerializeObject(new { name = NewGuildName });
try
{
WebWrapper.Patch(editGuildUrl, token, newNameJson);
}
catch (Exception ex)
{
DebugLogger.Log($"Exception ocurred while editing guild ({guild.Name}) name: " + ex.Message, MessageLevel.Error);
}
}
/// <summary>
/// Creates an empty guild with only this client in it given the following name.
/// Unknown if works on bot accounts or not.
/// </summary>
/// <param name="GuildName">The name of the guild you wish to create.</param>
/// <returns>the created DiscordServer</returns>
public DiscordServer CreateGuild(string GuildName)
{
string createGuildUrl = Endpoints.BaseAPI + Endpoints.Guilds;
string req = JsonConvert.SerializeObject(new { name = GuildName });
try
{
var response = JObject.Parse(WebWrapper.Post(createGuildUrl, token, req));
if (response != null)
{
DiscordServer server = new DiscordServer();
server.JoinedAt = response["joined_at"].ToObject<DateTime>();
server.ID = response["id"].ToString();
server.Name = response["name"].ToString();
server.parentclient = this;
string channelGuildUrl = createGuildUrl + $"/{server.ID}" + Endpoints.Channels;
var channelRespone = JArray.Parse(WebWrapper.Get(channelGuildUrl, token));
foreach (var item in channelRespone.Children())
{
server.Channels.Add(new DiscordChannel
{
Client = this,
Name = item["name"].ToString(),
ID = item["id"].ToString(),
Topic = item["topic"].ToString(),
Private = item["is_private"].ToObject<bool>(),
Type = item["type"].ToObject<ChannelType>()
});
}
server.AddMember(Me);
server.Owner = server.GetMemberByKey(response["owner_id"].ToString());
if (server.Owner == null)
DebugLogger.Log("Owner is null in CreateGuild!", MessageLevel.Critical);
ServersList.Add(server);
return server;
}
}
catch (Exception ex)
{
DebugLogger.Log("Exception ocurred while creating guild: " + ex.Message, MessageLevel.Error);
}
return null;
}
/// <summary>
/// Assigns the specified roles to a member, given you have the permission.
/// </summary>
/// <param name="guild">The guild you and the user are in.</param>
/// <param name="roles">The roles you wish to assign them.</param>
/// <param name="member">The member you wish to assign the role to.</param>
public void AssignRoleToMember(DiscordServer guild, List<DiscordRole> roles, DiscordMember member)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Members + $"/{member.ID}";
List<string> rolesAsIds = new List<string>();
roles.ForEach(x => rolesAsIds.Add(x.ID));
string message = JsonConvert.SerializeObject(new { roles = rolesAsIds.ToArray() });
try
{
WebWrapper.Patch(url, token, message);
}
catch (Exception ex)
{
DebugLogger.Log($"Exception ocurred while assigning {roles.Count} role(s) to member ({member.Username}): "
+ ex.Message, MessageLevel.Error);
}
}
/// <summary>
/// Assigns a specified role to a member, given you have the permission.
/// </summary>
/// <param name="guild">The guild you and the user are in.</param>
/// <param name="role">The role you wish to assign them.</param>
/// <param name="member">The member you wish to assign the role to.</param>
public void AssignRoleToMember(DiscordServer guild, DiscordRole role, DiscordMember member)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Members + $"/{member.ID}";
string message = JsonConvert.SerializeObject(new { roles = new string[] { role.ID } });
try
{
WebWrapper.Patch(url, token, message);
}
catch (Exception ex)
{
DebugLogger.Log($"Exception ocurred while assigning role ({role.Name}) to member ({member.Username}): "
+ ex.Message, MessageLevel.Error);
}
}
/// <summary>
/// Retrieves a DiscordMember List of members banned in the specified server.
/// </summary>
/// <param name="server"></param>
/// <returns>Null if no permission.</returns>
public List<DiscordMember> GetBans(DiscordServer server)
{
List<DiscordMember> returnVal = new List<DiscordMember>();
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{server.ID}" + Endpoints.Bans;
try
{
var __res = WebWrapper.Get(url, token);
var permissionCheck = JObject.Parse(__res);
{
if (!permissionCheck["message"].IsNullOrEmpty())
return null; //no permission
}
JArray response = JArray.Parse(__res);
if (response != null && response.Count > 0)
{
DebugLogger.Log($"Ban count: {response.Count}");
foreach (var memberStub in response)
{
DiscordMember temp = JsonConvert.DeserializeObject<DiscordMember>(memberStub["user"].ToString());
if (temp != null)
returnVal.Add(temp);
else
DebugLogger.Log($"memberStub[\"user\"] was null?! Username: {memberStub["user"]["username"].ToString()} ID: {memberStub["user"]["username"].ToString()}", MessageLevel.Error);
}
}
else
return returnVal;
}
catch (Exception ex)
{
DebugLogger.Log($"An error ocurred while retrieving bans for server \"{server.Name}\"\n\tMessage: {ex.Message}\n\tStack: {ex.StackTrace}",
MessageLevel.Error);
}
return returnVal;
}
/// <summary>
/// Bans a specified DiscordMember from the guild that's assumed from their
/// parent property.
/// </summary>
/// <param name="member"></param>
/// <param name="serverOverride"></param>
/// <param name="days"></param>
/// <returns></returns>
public DiscordMember BanMember(DiscordMember member, DiscordServer serverOverride, int days = 0)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{serverOverride.ID}" + Endpoints.Bans + $"/{member.ID}";
url += $"?delete-message-days={days}";
try
{
WebWrapper.Put(url, token);
return member;
}
catch (Exception ex)
{
DebugLogger.Log($"Error during BanMember\n\t{ex.Message}\n\t{ex.StackTrace}", MessageLevel.Error);
return null;
}
}
/// <summary>
/// Iterates through a server's members and removes offline users.
/// </summary>
/// <param name="server"></param>
/// <returns>The amount of users cleared.</returns>
public int ClearOfflineUsersFromServer(DiscordServer server)
{
return server.ClearOfflineMembers();
}
//eh
private void GetChannelsList(JObject m)
{
if (ServersList == null)
ServersList = new List<DiscordServer>();
foreach (var j in m["d"]["guilds"])
{
if (!j["unavailable"].IsNullOrEmpty() && j["unavailable"].ToObject<bool>() == true)
continue; //unavailable server
DiscordServer temp = new DiscordServer();
temp.parentclient = this;
temp.JoinedAt = j["joined_at"].ToObject<DateTime>();
temp.ID = j["id"].ToString();
temp.Name = j["name"].ToString();
if (!j["icon"].IsNullOrEmpty())
temp.icon = j["icon"].ToString();
else
temp.icon = null;
//temp.owner_id = j["owner_id"].ToString();
List<DiscordChannel> tempSubs = new List<DiscordChannel>();
List<DiscordRole> tempRoles = new List<DiscordRole>();
foreach (var u in j["roles"])
{
DiscordRole t = new DiscordRole
{
Color = new DiscordSharp.Color(u["color"].ToObject<int>().ToString("x")),
Name = u["name"].ToString(),
Permissions = new DiscordPermission(u["permissions"].ToObject<uint>()),
Position = u["position"].ToObject<int>(),
Managed = u["managed"].ToObject<bool>(),
ID = u["id"].ToString(),
Hoist = u["hoist"].ToObject<bool>()
};
tempRoles.Add(t);
}
temp.Roles = tempRoles;
foreach (var u in j["channels"])
{
DiscordChannel tempSub = new DiscordChannel();
tempSub.Client = this;
tempSub.ID = u["id"].ToString();
tempSub.Name = u["name"].ToString();
tempSub.Type = u["type"].ToObject<ChannelType>();
if (!u["topic"].IsNullOrEmpty())
tempSub.Topic = u["topic"].ToString();
if (tempSub.Type == ChannelType.Voice && !u["bitrate"].IsNullOrEmpty())
tempSub.Bitrate = u["bitrate"].ToObject<int>();
tempSub.Parent = temp;
List<DiscordPermissionOverride> permissionoverrides = new List<DiscordPermissionOverride>();
foreach (var o in u["permission_overwrites"])
{
DiscordPermissionOverride dpo = new DiscordPermissionOverride(o["allow"].ToObject<uint>(), o["deny"].ToObject<uint>());
dpo.id = o["id"].ToString();
if (o["type"].ToString() == "member")
dpo.type = DiscordPermissionOverride.OverrideType.member;
else
dpo.type = DiscordPermissionOverride.OverrideType.role;
permissionoverrides.Add(dpo);
}
tempSub.PermissionOverrides = permissionoverrides;
tempSubs.Add(tempSub);
}
temp.Channels = tempSubs;
foreach (var mm in j["members"])
{
DiscordMember member = JsonConvert.DeserializeObject<DiscordMember>(mm["user"].ToString());
member.parentclient = this;
member.Roles = new List<DiscordRole>();
JArray rawRoles = JArray.Parse(mm["roles"].ToString());
if (rawRoles.Count > 0)
{
foreach (var role in rawRoles.Children())
{
member.Roles.Add(temp.Roles.Find(x => x.ID == role.Value<string>()));
}
}
else
{
member.Roles.Add(temp.Roles.Find(x => x.Name == "@everyone"));
}
temp.AddMember(member);
}
if (!j["presences"].IsNullOrEmpty())
{
foreach (var presence in j["presences"])
{
DiscordMember member = temp.GetMemberByKey(presence["user"]["id"].ToString());
if (member != null)
{
member.SetPresence(presence["status"].ToString());
if (!presence["game"].IsNullOrEmpty())
{
member.CurrentGame = presence["game"]["name"].ToString();
if (presence["d"]["game"]["type"].ToObject<int>() == 1)
{
member.Streaming = true;
if (presence["d"]["game"]["url"].ToString() != null)
member.StreamURL = presence["d"]["game"]["url"].ToString();
}
}
}
}
}
temp.Region = j["region"].ToString();
temp.Owner = temp.GetMemberByKey(j["owner_id"].ToString());
ServersList.Add(temp);
}
if (PrivateChannels == null)
PrivateChannels = new List<DiscordPrivateChannel>();
foreach (var privateChannel in m["d"]["private_channels"])
{
DiscordPrivateChannel tempPrivate = JsonConvert.DeserializeObject<DiscordPrivateChannel>(privateChannel.ToString());
tempPrivate.Client = this;
tempPrivate.user_id = privateChannel["recipient"]["id"].ToString();
DiscordServer potentialServer = new DiscordServer();
ServersList.ForEach(x =>
{
if (x.GetMemberByKey(privateChannel["recipient"]["id"].ToString()) != null)
{
potentialServer = x;
}
});
if (potentialServer.Owner != null) //should be a safe test..i hope
{
DiscordMember recipient = potentialServer.GetMemberByKey(privateChannel["recipient"]["id"].ToString());
if (recipient != null)
{
tempPrivate.Recipient = recipient;
}
else
{
DebugLogger.Log("Recipient was null!!!!", MessageLevel.Critical);
}
}
else
{
DebugLogger.Log("No potential server found for user's private channel null! This will probably fix itself.", MessageLevel.Debug);
}
PrivateChannels.Add(tempPrivate);
}
}
/// <summary>
/// Edits a role with the new role information.
/// </summary>
/// <param name="guild">The guild the role is in.</param>
/// <param name="newRole">the new role.</param>
/// <returns>The newly edited role returned from Discord.</returns>
public DiscordRole EditRole(DiscordServer guild, DiscordRole newRole)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Roles + $"/{newRole.ID}";
string request = JsonConvert.SerializeObject(
new
{
color = decimal.Parse(newRole.Color.ToDecimal().ToString()),
hoist = newRole.Hoist,
name = newRole.Name,
permissions = newRole.Permissions.GetRawPermissions()
}
);
try
{
var result = JObject.Parse(WebWrapper.Patch(url, token, request));
if (result != null)
{
DiscordRole d = new DiscordRole
{
Color = new Color(result["color"].ToObject<int>().ToString("x")),
Hoist = result["hoist"].ToObject<bool>(),
ID = result["id"].ToString(),
Managed = result["managed"].ToObject<bool>(),
Name = result["name"].ToString(),
Permissions = new DiscordPermission(result["permissions"].ToObject<uint>()),
Position = result["position"].ToObject<int>()
};
ServersList.Find(x => x.ID == guild.ID).Roles.Remove(d);
ServersList.Find(x => x.ID == guild.ID).Roles.Add(d);
return d;
}
}
catch (Exception ex)
{
DebugLogger.Log($"Error ocurred while editing role ({newRole.Name}): {ex.Message}", MessageLevel.Error);
}
return null;
}
public void UpdateServer(DiscordServer server)
{
Server = server;
}
/// <summary>
/// Deletes a specified role.
/// </summary>
/// <param name="guild">The guild the role is in.</param>
/// <param name="role">The role to delete.</param>
public void DeleteRole(DiscordServer guild, DiscordRole role)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Roles + $"/{role.ID}";
try
{
WebWrapper.Delete(url, token);
}
catch (Exception ex)
{
DebugLogger.Log($"Error ocurred while deleting role ({role.Name}): {ex.Message}", MessageLevel.Error);
}
}
private void GuildCreateEvents(JObject message)
{
DiscordGuildCreateEventArgs e = new DiscordGuildCreateEventArgs();
e.RawJson = message;
DiscordServer server = new DiscordServer();
server.JoinedAt = message["d"]["joined_at"].ToObject<DateTime>();
server.parentclient = this;
server.ID = message["d"]["id"].ToString();
server.Name = message["d"]["name"].ToString();
server.Members = new Dictionary<ID, DiscordMember>();
server.Channels = new List<DiscordChannel>();
server.Roles = new List<DiscordRole>();
foreach (var roll in message["d"]["roles"])
{
DiscordRole t = new DiscordRole
{
Color = new DiscordSharp.Color(roll["color"].ToObject<int>().ToString("x")),
Name = roll["name"].ToString(),
Permissions = new DiscordPermission(roll["permissions"].ToObject<uint>()),
Position = roll["position"].ToObject<int>(),
Managed = roll["managed"].ToObject<bool>(),
ID = roll["id"].ToString(),
Hoist = roll["hoist"].ToObject<bool>()
};
server.Roles.Add(t);
}
foreach (var chn in message["d"]["channels"])
{
DiscordChannel tempChannel = new DiscordChannel();
tempChannel.Client = this;
tempChannel.ID = chn["id"].ToString();
tempChannel.Type = chn["type"].ToObject<ChannelType>();
if (!chn["topic"].IsNullOrEmpty())
tempChannel.Topic = chn["topic"].ToString();
if (tempChannel.Type == ChannelType.Voice && !chn["bitrate"].IsNullOrEmpty())
tempChannel.Bitrate = chn["bitrate"].ToObject<int>();
tempChannel.Name = chn["name"].ToString();
tempChannel.Private = false;
tempChannel.PermissionOverrides = new List<DiscordPermissionOverride>();
tempChannel.Parent = server;
foreach (var o in chn["permission_overwrites"])
{
if (tempChannel.Type == ChannelType.Voice)
continue;
DiscordPermissionOverride dpo = new DiscordPermissionOverride(o["allow"].ToObject<uint>(), o["deny"].ToObject<uint>());
dpo.id = o["id"].ToString();
if (o["type"].ToString() == "member")
dpo.type = DiscordPermissionOverride.OverrideType.member;
else
dpo.type = DiscordPermissionOverride.OverrideType.role;
tempChannel.PermissionOverrides.Add(dpo);
}
server.Channels.Add(tempChannel);
}
foreach (var mbr in message["d"]["members"])
{
DiscordMember member = JsonConvert.DeserializeObject<DiscordMember>(mbr["user"].ToString());
if(mbr["nick"] != null)
member.Nickname = mbr["nick"].ToString();
member.parentclient = this;
member.Parent = server;
foreach (var rollid in mbr["roles"])
{
member.Roles.Add(server.Roles.Find(x => x.ID == rollid.ToString()));
}
if (member.Roles.Count == 0)
member.Roles.Add(server.Roles.Find(x => x.Name == "@everyone"));
server.AddMember(member);
}
foreach (var voiceStateJSON in message["d"]["voice_states"]) {
DiscordVoiceState voiceState = JsonConvert.DeserializeObject<DiscordVoiceState>(voiceStateJSON.ToString());
DiscordMember member = server.GetMemberByKey(voiceState.UserID);
member.CurrentVoiceChannel = server.Channels.Find(x => x.ID == voiceState.ChannelID);
member.VoiceState = voiceState;
}
server.Owner = server.GetMemberByKey(message["d"]["owner_id"].ToString());
e.Server = server;
if (!message["d"]["unavailable"].IsNullOrEmpty() && message["d"]["unavailable"].ToObject<bool>() == false)
{
var oldServer = ServersList.Find(x => x.ID == server.ID);
if (oldServer != null && oldServer.Unavailable)
ServersList.Remove(oldServer);
ServersList.Add(server);
DebugLogger.Log($"Guild with ID {server.ID} ({server.Name}) became available.");
GuildAvailable?.Invoke(this, e);
return;
}
ServersList.Add(server);
GuildCreated?.Invoke(this, e);
}
/// <summary>
/// Changes the icon assosciated with the guild. Discord will perform jpeg compression and this image is automatically downscaled.
/// </summary>
/// <param name="image">The bitmap object associated </param>
/// <param name="guild">The guild of the icon you wish to change.</param>
public void ChangeGuildIcon(Bitmap image, DiscordServer guild)
{
Bitmap resized = new Bitmap((Image)image, 200, 200);
string base64 = Convert.ToBase64String(Utils.ImageToByteArray(resized));
string type = "image/jpeg;base64";
string req = $"data:{type},{base64}";
string guildjson = JsonConvert.SerializeObject(new { icon = req, name = guild.Name });
string url = Endpoints.BaseAPI + Endpoints.Guilds + "/" + guild.ID;
try
{
var result = JObject.Parse(WebWrapper.Patch(url, token, guildjson));
}
catch (Exception ex)
{
DebugLogger.Log($"Error ocurred while changing guild {guild.Name}'s icon: {ex.Message}", MessageLevel.Error);
}
}
/// <summary>
/// Creates either a text or voice channel in a DiscordServer given a name. Given you have the permission of course.
/// </summary>
/// <param name="server">The server to create the channel in.</param>
/// <param name="ChannelName">The name of the channel (will automatically be lowercased if text)</param>
/// <param name="voice">True if you want the channel to be a voice channel.</param>
/// <returns>The newly created DiscordChannel</returns>
public DiscordChannel CreateChannel(DiscordServer server, string ChannelName, bool voice)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{server.ID}" + Endpoints.Channels;
var reqJson = JsonConvert.SerializeObject(new { name = ChannelName, type = voice ? "voice" : "text" });
try
{
var result = JObject.Parse(WebWrapper.Post(url, token, reqJson));
if (result != null)
{
DiscordChannel dc = new DiscordChannel
{
Client = this,
Name = result["name"].ToString(),
ID = result["id"].ToString(),
Type = result["type"].ToObject<ChannelType>(),
Private = result["is_private"].ToObject<bool>(),
};
if (!result["topic"].IsNullOrEmpty())
dc.Topic = result["topic"].ToString();
if (dc.Type == ChannelType.Voice && !result["bitrate"].IsNullOrEmpty())
dc.Bitrate = result["bitrate"].ToObject<int>();
server.Channels.Add(dc);
return dc;
}
}
catch (Exception ex)
{
DebugLogger.Log("Exception ocurred while creating channel: " + ex.Message, MessageLevel.Error);
}
return null;
}
/// <summary>
/// Removes a ban on the user.
/// </summary>
/// <param name="guild">The guild to lift the ban from.</param>
/// <param name="member">The DiscordMember object of the user to lift the ban from, assuming you have it.</param>
public void RemoveBan(DiscordServer guild, DiscordMember member)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Bans + $"/{member.ID}";
try
{
WebWrapper.Delete(url, token);
}
catch (Exception ex)
{
DebugLogger.Log($"Error during RemoveBan\n\tMessage: {ex.Message}\n\tStack: {ex.StackTrace}", MessageLevel.Error);
}
}
/// <summary>
/// Creates a default role in the specified guild.
/// </summary>
/// <param name="guild">The guild to make the role in.</param>
/// <returns>The newly created role.</returns>
public DiscordRole CreateRole(DiscordServer guild)
{
string url = Endpoints.BaseAPI + Endpoints.Guilds + $"/{guild.ID}" + Endpoints.Roles;
try
{
var result = JObject.Parse(WebWrapper.Post(url, token, ""));
if (result != null)
{
DiscordRole d = new DiscordRole
{
Color = new Color(result["color"].ToObject<int>().ToString("x")),
Hoist = result["hoist"].ToObject<bool>(),
ID = result["id"].ToString(),
Managed = result["managed"].ToObject<bool>(),
Name = result["name"].ToString(),
Permissions = new DiscordPermission(result["permissions"].ToObject<uint>()),
Position = result["position"].ToObject<int>()
};
ServersList.Find(x => x.ID == guild.ID).Roles.Add(d);
return d;
}
}
catch (Exception ex)
{
DebugLogger.Log($"Error ocurred while creating role in guild {guild.Name}: {ex.Message}", MessageLevel.Error);
}
return null;
}
private void PopulateChannelsList(DiscordServer server)
{
//channelsList.Items.Clear();
Dispatcher.Invoke(() =>
{
server.channels.ForEach(x =>
{
//if (x.type == "text")
// channelsList.Items.Add($"#{x.name}");
});
});
}
private void GuildUpdateEvents(JObject message)
{
DiscordServer oldServer = ServersList.Find(x => x.id == message["d"]["id"].ToString());
DiscordServer newServer = new DiscordServer
{
name = message["d"]["name"].ToString(),
id = message["d"]["name"].ToString()
};
newServer.parentclient = this;
newServer.roles = new List<DiscordRole>();
newServer.region = message["d"]["region"].ToString();
if(!message["d"]["icon"].IsNullOrEmpty())
{
newServer.icon = message["d"]["icon"].ToString();
}
if (!message["d"]["roles"].IsNullOrEmpty())
{
foreach (var roll in message["d"]["roles"])
{
DiscordRole t = new DiscordRole
{
color = new DiscordSharp.Color(roll["color"].ToObject<int>().ToString("x")),
name = roll["name"].ToString(),
permissions = new DiscordPermission(roll["permissions"].ToObject<uint>()),
position = roll["position"].ToObject<int>(),
managed = roll["managed"].ToObject<bool>(),
id = roll["id"].ToString(),
hoist = roll["hoist"].ToObject<bool>()
};
newServer.roles.Add(t);
}
}
else
{
newServer.roles = oldServer.roles;
}
newServer.channels = new List<DiscordChannel>();
if (!message["d"]["channels"].IsNullOrEmpty())
{
foreach (var u in message["d"]["channels"])
{
DiscordChannel tempSub = new DiscordChannel();
tempSub.ID = u["id"].ToString();
tempSub.Name = u["name"].ToString();
tempSub.Type = u["type"].ToObject<ChannelType>();
tempSub.Topic = u["topic"].ToString();
tempSub.parent = newServer;
List<DiscordPermissionOverride> permissionoverrides = new List<DiscordPermissionOverride>();
foreach (var o in u["permission_overwrites"])
{
DiscordPermissionOverride dpo = new DiscordPermissionOverride(o["allow"].ToObject<uint>(), o["deny"].ToObject<uint>());
dpo.type = o["type"].ToObject<DiscordPermissionOverride.OverrideType>();
dpo.id = o["id"].ToString();
permissionoverrides.Add(dpo);
}
tempSub.PermissionOverrides = permissionoverrides;
newServer.channels.Add(tempSub);
}
}
else
{
newServer.channels = oldServer.channels;
}
if (!message["d"]["members"].IsNullOrEmpty())
{
foreach (var mm in message["d"]["members"])
{
DiscordMember member = JsonConvert.DeserializeObject<DiscordMember>(mm["user"].ToString());
member.parentclient = this;
member.Parent = newServer;
JArray rawRoles = JArray.Parse(mm["roles"].ToString());
if (rawRoles.Count > 0)
{
foreach (var role in rawRoles.Children())
{
member.Roles.Add(newServer.roles.Find(x => x.id == role.Value<string>()));
}
}
else
{
member.Roles.Add(newServer.roles.Find(x => x.name == "@everyone"));
}
newServer.members.Add(member);
}
}
else
{
newServer.members = oldServer.members;
}
if (!message["d"]["owner_id"].IsNullOrEmpty())
{
newServer.owner = newServer.members.Find(x => x.ID == message["d"]["owner_id"].ToString());
DebugLogger.Log($"Transferred ownership from user '{oldServer.owner.Username}' to {newServer.owner.Username}.");
}
ServersList.Remove(oldServer);
ServersList.Add(newServer);
DiscordServerUpdateEventArgs dsuea = new DiscordServerUpdateEventArgs { NewServer = newServer, OldServer = oldServer };
if (GuildUpdated != null)
GuildUpdated(this, dsuea);
}
public List<DiscordRole> GetRoles(DiscordServer server)
{
return null;
}
/// <summary> /// Sends an http DELETE request to leave the server you send in this parameter. /// </summary> /// <param name="server">The DiscordServer object you want to leave.</param> public void LeaveServer(DiscordServer server) => LeaveServer(server.ID);
private void GuildCreateEvents(JObject message)
{
DiscordGuildCreateEventArgs e = new DiscordGuildCreateEventArgs();
e.RawJson = message;
DiscordServer server = new DiscordServer();
server.parentclient = this;
server.id = message["d"]["id"].ToString();
server.name = message["d"]["name"].ToString();
server.members = new List<DiscordMember>();
server.channels = new List<DiscordChannel>();
server.roles = new List<DiscordRole>();
foreach (var roll in message["d"]["roles"])
{
DiscordRole t = new DiscordRole
{
color = new DiscordSharp.Color(roll["color"].ToObject<int>().ToString("x")),
name = roll["name"].ToString(),
permissions = new DiscordPermission(roll["permissions"].ToObject<uint>()),
position = roll["position"].ToObject<int>(),
managed = roll["managed"].ToObject<bool>(),
id = roll["id"].ToString(),
hoist = roll["hoist"].ToObject<bool>()
};
server.roles.Add(t);
}
foreach (var chn in message["d"]["channels"])
{
DiscordChannel tempChannel = new DiscordChannel();
tempChannel.ID = chn["id"].ToString();
tempChannel.Type = chn["type"].ToObject<ChannelType>();
tempChannel.Topic = chn["topic"].ToString();
tempChannel.Name = chn["name"].ToString();
tempChannel.Private = false;
tempChannel.PermissionOverrides = new List<DiscordPermissionOverride>();
tempChannel.parent = server;
foreach (var o in chn["permission_overwrites"])
{
if (tempChannel.Type == ChannelType.Voice)
continue;
DiscordPermissionOverride dpo = new DiscordPermissionOverride(o["allow"].ToObject<uint>(), o["deny"].ToObject<uint>());
dpo.id = o["id"].ToString();
if (o["type"].ToString() == "member")
dpo.type = DiscordPermissionOverride.OverrideType.member;
else
dpo.type = DiscordPermissionOverride.OverrideType.role;
tempChannel.PermissionOverrides.Add(dpo);
}
server.channels.Add(tempChannel);
}
foreach(var mbr in message["d"]["members"])
{
DiscordMember member = JsonConvert.DeserializeObject<DiscordMember>(mbr["user"].ToString());
member.parentclient = this;
member.Parent = server;
foreach(var rollid in mbr["roles"])
{
member.Roles.Add(server.roles.Find(x => x.id == rollid.ToString()));
}
if (member.Roles.Count == 0)
member.Roles.Add(server.roles.Find(x => x.name == "@everyone"));
server.members.Add(member);
}
server.owner = server.members.Find(x => x.ID == message["d"]["owner_id"].ToString());
ServersList.Add(server);
e.server = server;
if (GuildCreated != null)
GuildCreated(this, e);
}
/// <summary> /// (Owner only, non-bot only) Sends an http DELETE request to delete the server you specify. /// </summary> /// <param name="server">The DiscordServer object you want to delete.</param> public void DeleteServer(DiscordServer server) => DeleteServer(server.ID);
//eh
private void GetChannelsList(JObject m)
{
if (ServersList == null)
ServersList = new List<DiscordServer>();
foreach(var j in m["d"]["guilds"])
{
DiscordServer temp = new DiscordServer();
temp.parentclient = this;
temp.id = j["id"].ToString();
temp.name = j["name"].ToString();
if (!j["icon"].IsNullOrEmpty())
temp.icon = j["icon"].ToString();
else
temp.icon = null;
//temp.owner_id = j["owner_id"].ToString();
List<DiscordChannel> tempSubs = new List<DiscordChannel>();
List<DiscordRole> tempRoles = new List<DiscordRole>();
foreach(var u in j["roles"])
{
DiscordRole t = new DiscordRole
{
color = new DiscordSharp.Color(u["color"].ToObject<int>().ToString("x")),
name = u["name"].ToString(),
permissions = new DiscordPermission(u["permissions"].ToObject<uint>()),
position = u["position"].ToObject<int>(),
managed = u["managed"].ToObject<bool>(),
id = u["id"].ToString(),
hoist = u["hoist"].ToObject<bool>()
};
tempRoles.Add(t);
}
temp.roles = tempRoles;
foreach(var u in j["channels"])
{
DiscordChannel tempSub = new DiscordChannel();
tempSub.ID = u["id"].ToString();
tempSub.Name = u["name"].ToString();
tempSub.Type = u["type"].ToObject<ChannelType>();
tempSub.Topic = u["topic"].ToString();
tempSub.parent = temp;
List<DiscordPermissionOverride> permissionoverrides = new List<DiscordPermissionOverride>();
foreach(var o in u["permission_overwrites"])
{
DiscordPermissionOverride dpo = new DiscordPermissionOverride(o["allow"].ToObject<uint>(), o["deny"].ToObject<uint>());
dpo.id = o["id"].ToString();
if (o["type"].ToString() == "member")
dpo.type = DiscordPermissionOverride.OverrideType.member;
else
dpo.type = DiscordPermissionOverride.OverrideType.role;
permissionoverrides.Add(dpo);
}
tempSub.PermissionOverrides = permissionoverrides;
tempSubs.Add(tempSub);
}
temp.channels = tempSubs;
foreach(var mm in j["members"])
{
DiscordMember member = JsonConvert.DeserializeObject<DiscordMember>(mm["user"].ToString());
member.parentclient = this;
//member.ID = mm["user"]["id"].ToString();
//member.Username = mm["user"]["username"].ToString();
//member.Avatar = mm["user"]["avatar"].ToString();
//member.Discriminator = mm["user"]["discriminator"].ToString();
member.Roles = new List<DiscordRole>();
JArray rawRoles = JArray.Parse(mm["roles"].ToString());
if(rawRoles.Count > 0)
{
foreach(var role in rawRoles.Children())
{
member.Roles.Add(temp.roles.Find(x => x.id == role.Value<string>()));
}
}
else
{
member.Roles.Add(temp.roles.Find(x => x.name == "@everyone"));
}
member.Parent = temp;
temp.members.Add(member);
}
foreach(var presence in j["presence"])
{
DiscordMember member = temp.members.Find(x => x.ID == presence["user"]["id"].ToString());
member.SetPresence(presence["status"].ToString());
if (!presence["game"].IsNullOrEmpty())
member.CurrentGame = presence["game"]["name"].ToString();
}
temp.region = j["region"].ToString();
temp.owner = temp.members.Find(x => x.ID == j["owner_id"].ToString());
ServersList.Add(temp);
}
if (PrivateChannels == null)
PrivateChannels = new List<DiscordPrivateChannel>();
foreach(var privateChannel in m["d"]["private_channels"])
{
DiscordPrivateChannel tempPrivate = JsonConvert.DeserializeObject<DiscordPrivateChannel>(privateChannel.ToString());
DiscordServer potentialServer = new DiscordServer();
ServersList.ForEach(x =>
{
x.members.ForEach(y =>
{
if (y.ID == privateChannel["recipient"]["id"].ToString())
potentialServer = x;
});
});
if(potentialServer.owner != null) //should be a safe test..i hope
{
DiscordMember recipient = potentialServer.members.Find(x => x.ID == privateChannel["recipient"]["id"].ToString());
if (recipient != null)
{
tempPrivate.recipient = recipient;
PrivateChannels.Add(tempPrivate);
}
else
{
DebugLogger.Log("Recipient was null!!!!", MessageLevel.Critical);
}
}
else
{
DebugLogger.Log("No potential server found for user's private channel null!!!!", MessageLevel.Critical);
}
}
}
