internal BindableGuildChannel(
IMessenger messenger,
IClipboardService clipboardService,
IDiscordService discordService,
QuarrelClient quarrelClient,
IDispatcherService dispatcherService,
GuildChannel channel,
GuildMember selfMember,
BindableCategoryChannel?parent = null) :
base(messenger, clipboardService, discordService, quarrelClient, dispatcherService, channel)
{
CategoryChannel = parent;
if (CategoryChannel is null)
{
Permissions = new Permissions();
var roles = selfMember.GetRoles();
foreach (var role in roles)
{
Permissions += role.Permissions;
}
}
else
{
Permissions = CategoryChannel.Permissions;
}
Guard.IsNotNull(channel.PermissionOverwrites, nameof(channel.PermissionOverwrites));
ApplyOverrides(channel.PermissionOverwrites, selfMember);
}
public async Task RoleList()
{
EmbedBuilder builder = new EmbedBuilder();
try
{
GuildChannel guild = new GuildChannel(Context.Guild);
if (guild.RoleList[0] == 0)
{
builder.AddField("Error", "There are no autoroles");
await ReplyAsync("", false, builder.Build());
}
else
{
var list = new List <string>();
foreach (ulong role in guild.RoleList)
{
IRole cur = Context.Guild.GetRole(role);
list.Add($"Name: {cur.Name}, Id: {cur.Id}");
}
builder.AddField("Roles", string.Join(",\n", list));
await ReplyAsync("", false, builder.Build());
}
}
catch (Exception ex)
{
builder.AddField("Error", ex.ToString());
await ReplyAsync("", false, builder.Build());
}
}
public async Task AddRole(ulong role)
{
var serverroles = new List <ulong>();
foreach (IRole Role in Context.Guild.Roles)
{
serverroles.Add(Role.Id);
}
try
{
if (serverroles.Contains(role))
{
GuildChannel guild = new GuildChannel(Context.Guild);
guild.AddRole(role);
IRole cur = Context.Guild.GetRole(role);
await ReplyAsync($"{cur.Name} has been added to the list");
}
else
{
await ReplyAsync("Please use an id of a role in this server");
}
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
public async Task EnGuild()
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild.Id);
guild.Enable(Context.Guild.Id);
await ReplyAsync("this feature is now enabled on this guild");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
public async Task RemChannel(IChannel channel)
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild.Id);
guild.Remove(Context.Guild.Id, channel.Id);
await ReplyAsync($"{channel.Name} has been removed from the list");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
public async Task AddChannel(IChannel channel)
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild.Id);
guild.Add(Context.Guild.Id, channel.Id);
await ReplyAsync($"{channel.Name} has been added to the list");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
public async Task DisableXpGain()
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild);
guild.DisableXpGain();
await ReplyAsync("Xp gain is now disabled in this server");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
public async Task DisableDeleteLevelMessages()
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild);
guild.DisableLevelMessage();
await ReplyAsync("Level message deletion is now disabled in this server");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
public async Task EnableLevelMessages()
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild);
guild.EnableLevelMessage();
await ReplyAsync("Level messages are now enabled in this server");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
public async Task Disableautorole()
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild);
guild.DisableAutoRole();
await ReplyAsync("Autorole is now disabled in this server");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
public async Task EnGuild()
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild);
guild.EnableCommands();
await ReplyAsync("Commands are now disabled in specific channels in this guild");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
private async Task HandleUserJoin(SocketGuildUser arg)
{
GuildChannel guild = new GuildChannel(arg.Guild);
if (guild.AutoRoleOn)
{
if (guild.RoleList[0] != 0)
{
await arg.AddRoleAsync(arg.Guild.GetRole(guild.RoleList[0]));
}
}
await Client.SetGameAsync($"Guild users {++TotalUsers}", null, ActivityType.Streaming);
}
public async Task RemRole(ulong role)
{
try
{
GuildChannel guild = new GuildChannel(Context.Guild);
guild.RemoveRole(role);
IRole cur = Context.Guild.GetRole(role);
await ReplyAsync($"{cur.Name} has been removed from the list");
}
catch (Exception ex)
{
await ReplyAsync(ex.Message);
}
}
private static ChannelType TranslateChannelType(GuildChannel channel)
{
if (channel.IsText)
{
return(ChannelType.Text);
}
else if (channel.IsVoice)
{
return(ChannelType.Voice);
}
else
{
return(ChannelType.Category);
}
}
public async Task ListChannels()
{
List <string> list = new List <string>();
EmbedBuilder builder = new EmbedBuilder();
GuildChannel guild = new GuildChannel(Context.Guild.Id);
foreach (ulong channelid in guild.Channels)
{
var channel = await Context.Client.GetChannelAsync(channelid);
list.Add("#" + channel.Name);
}
builder.Title = "this is the list of channels";
builder.Description = string.Join("\n", list);
await ReplyAsync("", false, builder.Build());
}
public GuildChannel GetOutputGuildChannel()
{
GuildChannel guildChannel = VoterContext.GuildChannel.FirstOrDefault(g => g.GuildId == Context.Guild.Id);
if (guildChannel == null)
{
throw new Exception("No guild set. Please use '!votes channel set <channel>'");
}
guildChannel.Channel = SocketClient.GetGuild(guildChannel.GuildId).GetTextChannel(guildChannel.ChannelId);
if (guildChannel.Channel == null)
{
throw new Exception("No guild set. Please use '!votes channel set <channel>'");
}
return(guildChannel);
}
public void TestCreateVoiceChannel()
{
GuildChannel channel = null;
string name = GetRandomText();
AssertEvent <ChannelEventArgs>(
"ChannelCreated event never received",
async() => channel = await _testGuild.CreateVoiceChannel(name),
x => _targetBot.ChannelCreated += x,
x => _targetBot.ChannelCreated -= x,
(s, e) => e.Channel.Id == channel.Id);
AssertEvent <ChannelEventArgs>(
"ChannelDestroyed event never received",
async() => await channel.Delete(),
x => _targetBot.ChannelDestroyed += x,
x => _targetBot.ChannelDestroyed -= x,
(s, e) => e.Channel.Id == channel.Id);
}
/// <summary>
/// Gets a list of messages from a channel
/// </summary>
/// <param name="channelId">ID of the channel</param>
/// <param name="filters">Options for filtering out messages</param>
public static IReadOnlyList <DiscordMessage> GetChannelMessages(this DiscordSocketClient client, ulong channelId, MessageFilters filters = null)
{
var messages = ((DiscordClient)client).GetChannelMessages(channelId, filters);
if (client.Config.Cache)
{
DiscordChannel channel = client.GetChannel(channelId);
if (channel.Type == ChannelType.Text || channel.Type == ChannelType.Voice || channel.Type == ChannelType.Category)
{
GuildChannel guildChannel = channel.ToGuildChannel();
foreach (var message in messages)
{
message.GuildId = guildChannel.GuildId;
}
}
}
return(messages);
}
public static async Task <IReadOnlyList <DiscordMessage> > GetChannelMessagesAsync(this DiscordSocketClient client, ulong channelId, MessageFilters filters = null)
{
var messages = await((DiscordClient)client).GetChannelMessagesAsync(channelId, filters);
if (client.Config.Cache)
{
DiscordChannel channel = client.GetChannel(channelId);
if (channel.InGuild)
{
GuildChannel guildChannel = (GuildChannel)channel;
foreach (var message in messages)
{
message.GuildId = guildChannel.GuildId;
}
}
}
return(messages);
}
private static void DuplicateChannels(DiscordClient client, Guild targetGuild, Guild ourGuild, List <RoleDupe> ourRoles)
{
OrganizedChannelList channels = new OrganizedChannelList(targetGuild.GetChannels());
Console.WriteLine("Duplicating categories...");
//duplicate category channels
List <CategoryDupe> ourCategories = new List <CategoryDupe>();
foreach (var c in channels.Categories)
{
GuildChannel category;
try
{
category = client.GetGuildChannel(c.Id);
}
catch (DiscordHttpException e)
{
//ofcourse you could make it return no matter what error, but this is better for debugging
if (e.Code == DiscordError.MissingAccess)
{
continue;
}
else
{
throw;
}
}
//create the category
GuildChannel ourCategory = ourGuild.CreateChannel(new GuildChannelCreationProperties()
{
Name = category.Name, Type = ChannelType.Category
});
ourCategory.Modify(new GuildChannelProperties()
{
Position = category.Position
});
foreach (var overwrite in category.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
{
continue;
}
PermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourCategory.AddPermissionOverwrite(ourOverwrite);
}
CategoryDupe dupe = new CategoryDupe
{
TargetCategory = category,
OurCategory = ourCategory
};
ourCategories.Add(dupe);
Console.WriteLine($"Duplicated {category.Name}");
Thread.Sleep(50);
}
Console.WriteLine("Duplicating channels...");
//duplicate text channels
foreach (var c in channels.TextChannels)
{
TextChannel channel;
try
{
channel = client.GetTextChannel(c.Id);
}
catch (DiscordHttpException e)
{
//ofcourse you could make it return no matter what error, but this is better for debugging
if (e.Code == DiscordError.MissingAccess)
{
continue;
}
else
{
throw;
}
}
TextChannel ourChannel = ourGuild.CreateTextChannel(new GuildChannelCreationProperties()
{
Name = channel.Name, ParentId = channel.ParentId != null ? (ulong?)ourCategories.First(ca => ca.TargetCategory.Id == channel.ParentId).OurCategory.Id : null
});
ourChannel.Modify(new TextChannelProperties()
{
Nsfw = channel.Nsfw, Position = channel.Position, Topic = channel.Topic, SlowMode = channel.SlowMode
});
foreach (var overwrite in channel.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
{
continue;
}
PermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourChannel.AddPermissionOverwrite(ourOverwrite);
}
Console.WriteLine($"Duplicated {channel.Name}");
Thread.Sleep(50);
}
//duplicate voice channels
foreach (var c in channels.VoiceChannels)
{
VoiceChannel channel;
try
{
channel = client.GetVoiceChannel(c.Id);
}
catch (DiscordHttpException e)
{
//ofcourse you could make it return no matter what error, but this is better for debugging
if (e.Code == DiscordError.MissingAccess)
{
continue;
}
else
{
throw;
}
}
//create voice channels
VoiceChannel ourChannel = ourGuild.CreateVoiceChannel(new GuildChannelCreationProperties()
{
Name = channel.Name, ParentId = channel.ParentId != null ? (ulong?)ourCategories.First(ca => ca.TargetCategory.Id == channel.ParentId).OurCategory.Id : null
});
ourChannel.Modify(new VoiceChannelProperties()
{
Bitrate = channel.Bitrate, Position = channel.Position, UserLimit = channel.UserLimit
});
foreach (var overwrite in channel.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
{
continue;
}
PermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourChannel.AddPermissionOverwrite(ourOverwrite);
}
Console.WriteLine($"Duplicated {channel.Name}");
Thread.Sleep(50);
}
}
[Command("get"), RequireContext(ContextType.Guild), RequireUserPermission(GuildPermission.Administrator)] //? change from administrator?
public async Task GetOutputChannel()
{
GuildChannel guildchannel = GetOutputGuildChannel();
await ReplyAsync("#" + guildchannel.Channel.ToString());
}
private static void DuplicateChannels(Guild targetGuild, Guild ourGuild, List <RoleDupe> ourRoles)
{
OrganizedChannelList channels = new OrganizedChannelList(targetGuild.GetChannels());
Console.WriteLine("Duplicating categories...");
//duplicate category channels
List <CategoryDupe> ourCategories = new List <CategoryDupe>();
foreach (var category in channels.Categories)
{
//create the category
GuildChannel ourCategory = ourGuild.CreateChannel(category.Name, ChannelType.Category);
ourCategory.Modify(new GuildChannelProperties()
{
Position = category.Position
});
foreach (var overwrite in category.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
{
continue;
}
DiscordPermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourCategory.AddPermissionOverwrite(ourOverwrite);
}
CategoryDupe dupe = new CategoryDupe
{
TargetCategory = category,
OurCategory = ourCategory
};
ourCategories.Add(dupe);
Console.WriteLine($"Duplicated {category.Name}");
}
Console.WriteLine("Duplicating channels...");
//duplicate text channels
foreach (var c in channels.TextChannels)
{
TextChannel channel = c.ToTextChannel();
TextChannel ourChannel = ourGuild.CreateChannel(channel.Name, ChannelType.Text, channel.ParentId != null ? (ulong?)ourCategories.First(ca => ca.TargetCategory.Id == channel.ParentId).OurCategory.Id : null).ToTextChannel();
ourChannel.Modify(new TextChannelProperties()
{
Nsfw = channel.Nsfw, Position = channel.Position, Topic = channel.Topic, SlowMode = channel.SlowMode
});
foreach (var overwrite in channel.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
{
continue;
}
DiscordPermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourChannel.AddPermissionOverwrite(ourOverwrite);
}
Console.WriteLine($"Duplicated {channel.Name}");
}
//duplicate voice channels
foreach (var channel in channels.VoiceChannels)
{
//create voice channels
VoiceChannel ourChannel = ourGuild.CreateChannel(channel.Name, ChannelType.Voice, channel.ParentId != null ? (ulong?)ourCategories.First(ca => ca.TargetCategory.Id == channel.ParentId).OurCategory.Id : null).ToVoiceChannel();
ourChannel.Modify(new VoiceChannelProperties()
{
Bitrate = channel.Bitrate, Position = channel.Position, UserLimit = channel.UserLimit
});
foreach (var overwrite in channel.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
{
continue;
}
DiscordPermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourChannel.AddPermissionOverwrite(ourOverwrite);
}
Console.WriteLine($"Duplicated {channel.Name}");
}
}
private async Task HandleCommandAsync(SocketMessage arg)
{
string userpath = levelpath + arg.Author.Id + ".xml";
var msg = arg as SocketUserMessage;
if (msg == null)
{
return;
}
if (msg.Author.Id == _client.CurrentUser.Id || msg.Author.IsBot)
{
return;
}
int pos = 0;
LevelUser user = new LevelUser();
if (!File.Exists(userpath))
{
Console.WriteLine(user.AddNewUserRank(arg.Author.Id.ToString()));
}
Ranking.CheckUser(userpath, arg.Author.Id.ToString(), mineinv, baginv, craftlist);
UserInfo info = new UserInfo(arg.Author.Id);
info.AddMessage();
if (msg.HasStringPrefix("%", ref pos) || msg.HasMentionPrefix(_client.CurrentUser, ref pos))
{
var context = new SocketCommandContext(_client, msg);
GuildChannel guild = new GuildChannel(context.Guild.Id);
if (!guild.On || guild.Channels.Contains(arg.Channel.Id) == false || msg.Content == "%disable")
{
var result = await _commands.ExecuteAsync(context, pos, _services);
if (!result.IsSuccess)
{
Utils.CustomErrors(msg, result, context);
}
else if (result.IsSuccess)
{
info.AddCommand();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.WriteLine($"{DateTime.Now,-19} [{msg.Channel.Name}] [{msg.Author.Id}] Used {msg.ToString()}");
Console.ForegroundColor = ConsoleColor.White;
CommandUsed.CommandAdd();
}
}
else
{
var message = await context.Channel.GetMessageAsync(msg.Id);
await message.DeleteAsync();
CommandUsed.ClearAdd(1);
//await msg.Channel.SendMessageAsync("commands can't be used in this channel");
}
}
if (arg.Author.IsBot && arg.Author.Id != 372615866652557312)
{
return;
}
else
{
try
{
CommandUsed.GainedMessagesAdd();
Random rand = new Random();
user.Load(arg.Author.Id);
int xp = rand.Next(1, 5);
CommandUsed.TotalXpAdd(xp);
user.GainXpUser(arg, xp);
if (File.Exists($"./userimg.png"))
{
File.Delete($"./userimg.png");
}
}
catch (Exception ex)
{
Console.WriteLine($"User:{arg.Author.Id}" + ex.ToString());
}
}
}
private void WebSocket_OnMessageReceived(object sender, DiscordWebSocketMessage <GatewayOpcode> message)
{
Sequence = message.Sequence;
switch (message.Opcode)
{
case GatewayOpcode.Event:
/*
* Console.WriteLine(message.EventName);
*
* File.AppendAllText("Debug.log", $"{message.EventName}: {message.Data}\n");
*/
switch (message.EventName)
{
case "READY":
LoginEventArgs login = message.Data.ToObject <LoginEventArgs>().SetClient(this);
if (login.Application != null)
{
_appId = login.Application.Value <ulong>("id");
}
this.User = login.User;
this.UserSettings = login.Settings;
this.SessionId = login.SessionId;
if (Config.Cache && this.User.Type == DiscordUserType.User)
{
PrivateChannels.AddRange(login.PrivateChannels);
foreach (var presence in login.Presences)
{
Presences[presence.UserId] = presence;
}
foreach (var guild in login.Guilds)
{
ApplyGuild(GuildCache[guild.Id] = (SocketGuild)guild);
VoiceClients[guild.Id] = new DiscordVoiceClient(this, guild.Id);
}
foreach (var settings in login.ClientGuildSettings)
{
if (settings.GuildId.HasValue)
{
GuildSettings.Add(settings.Guild.Id, settings);
}
else
{
PrivateChannelSettings = settings.ChannelOverrides.ToList();
}
}
}
LoggedIn = true;
State = GatewayConnectionState.Connected;
if (OnLoggedIn != null)
{
Task.Run(() => OnLoggedIn.Invoke(this, login));
}
break;
case "USER_SETTINGS_UPDATE":
if (UserSettings == null)
{
}
UserSettings.Update((JObject)message.Data);
if (OnSettingsUpdated != null)
{
Task.Run(() => OnSettingsUpdated.Invoke(this, new DiscordSettingsEventArgs(UserSettings)));
}
break;
case "USER_GUILD_SETTINGS_UPDATE":
if (Config.Cache)
{
ClientGuildSettings settings = message.Data.ToObject <ClientGuildSettings>();
if (settings.GuildId.HasValue)
{
GuildSettings[settings.Guild.Id] = settings;
}
else
{
PrivateChannelSettings = settings.ChannelOverrides.ToList();
}
}
break;
case "USER_UPDATE":
DiscordUser user = message.Data.ToObject <DiscordUser>().SetClient(this);
if (user.Id == User.Id)
{
User.Update(user);
}
if (Config.Cache)
{
lock (PrivateChannels.Lock)
{
foreach (var dm in PrivateChannels)
{
foreach (var recipient in dm.Recipients)
{
if (recipient.Id == user.Id)
{
recipient.Update(user);
break;
}
}
}
}
}
if (OnUserUpdated != null)
{
Task.Run(() => OnUserUpdated.Invoke(this, new UserEventArgs(user)));
}
break;
case "GUILD_MEMBER_LIST_UPDATE":
OnMemberListUpdate?.Invoke(this, message.Data.ToObject <GuildMemberListEventArgs>());
break;
case "GUILD_CREATE":
if (Config.Cache || OnJoinedGuild != null)
{
var guild = message.Data.ToObject <SocketGuild>().SetClient(this);
VoiceClients[guild.Id] = new DiscordVoiceClient(this, guild.Id);
if (Config.Cache)
{
ApplyGuild(GuildCache[guild.Id] = guild);
}
if (OnJoinedGuild != null)
{
Task.Run(() => OnJoinedGuild.Invoke(this, new SocketGuildEventArgs(guild, Lurking.HasValue && Lurking.Value == guild.Id)));
}
}
break;
case "GUILD_UPDATE":
if (Config.Cache || OnGuildUpdated != null)
{
DiscordGuild guild = message.Data.ToObject <DiscordGuild>().SetClient(this);
if (Config.Cache)
{
GuildCache[guild.Id].Update(guild);
}
Task.Run(() => OnGuildUpdated?.Invoke(this, new GuildEventArgs(guild)));
}
break;
case "GUILD_DELETE":
{
UnavailableGuild guild = message.Data.ToObject <UnavailableGuild>();
VoiceClients.Remove(guild.Id);
if (Lurking.HasValue && Lurking.Value == guild.Id)
{
Lurking = null;
}
if (Config.Cache)
{
if (guild.Unavailable)
{
GuildCache[guild.Id].Unavailable = true;
}
else
{
GuildCache.Remove(guild.Id);
GuildSettings.Remove(guild.Id);
}
}
if (OnLeftGuild != null)
{
Task.Run(() => OnLeftGuild.Invoke(this, new GuildUnavailableEventArgs(guild)));
}
}
break;
case "GUILD_MEMBER_ADD":
if (Config.Cache || OnUserJoinedGuild != null)
{
var member = message.Data.ToObject <GuildMember>().SetClient(this);
if (Config.Cache)
{
GuildCache[member.GuildId].MemberCount++;
}
Task.Run(() => OnUserJoinedGuild?.Invoke(this, new GuildMemberEventArgs(member)));
}
break;
case "GUILD_MEMBER_REMOVE":
if (Config.Cache || OnUserLeftGuild != null)
{
var member = message.Data.ToObject <PartialGuildMember>().SetClient(this);
if (Config.Cache)
{
GuildCache[member.GuildId].MemberCount--;
}
Task.Run(() => OnUserLeftGuild?.Invoke(this, new MemberRemovedEventArgs(member)));
}
break;
case "GUILD_MEMBER_UPDATE":
if (Config.Cache || OnGuildMemberUpdated != null)
{
GuildMember member = message.Data.ToObject <GuildMember>().SetClient(this);
if (Config.Cache && member.User.Id == User.Id)
{
SocketGuild guild = this.GetCachedGuild(member.GuildId);
// Discord doesn't send us the user's JoinedAt on updates
member.JoinedAt = guild.ClientMember.JoinedAt;
ClientMembers[guild.Id] = member;
break;
}
Task.Run(() => OnGuildMemberUpdated.Invoke(this, new GuildMemberEventArgs(member)));
}
break;
case "GUILD_MEMBERS_CHUNK":
Task.Run(() => OnGuildMembersReceived?.Invoke(this, new GuildMembersEventArgs(message.Data.ToObject <GuildMemberList>().SetClient(this))));
break;
case "GIFT_CODE_CREATE":
if (OnGiftCodeCreated != null)
{
Task.Run(() => OnGiftCodeCreated.Invoke(this, message.Data.ToObject <GiftCodeCreatedEventArgs>()));
}
break;
case "GIFT_CODE_UPDATE":
if (OnGiftUpdated != null)
{
var gift = message.Data.ToObject <GiftCodeUpdatedEventArgs>().SetClient(this);
gift.Json = (JObject)message.Data;
Task.Run(() => OnGiftUpdated.Invoke(this, gift));
}
break;
case "PRESENCE_UPDATE":
if (Config.Cache || OnUserPresenceUpdated != null)
{
var presence = message.Data.ToObject <DiscordPresence>().SetClient(this);
if (Config.Cache)
{
if (Presences.TryGetValue(presence.UserId, out DiscordPresence existingPresence))
{
existingPresence.Update(presence);
presence = existingPresence;
}
else
{
Presences[presence.UserId] = presence;
}
}
if (OnUserPresenceUpdated != null)
{
Task.Run(() => OnUserPresenceUpdated.Invoke(this, new PresenceUpdatedEventArgs(presence)));
}
}
break;
case "VOICE_STATE_UPDATE":
DiscordVoiceState newState = message.Data.ToObject <DiscordVoiceState>().SetClient(this);
if (Config.Cache)
{
if (newState.Guild == null)
{
VoiceStates[newState.UserId].PrivateChannelVoiceState = newState;
}
else
{
VoiceStates[newState.UserId].GuildStates[newState.Guild.Id] = newState;
}
// we also store voice states within SocketGuilds, so make sure to update those.
foreach (var guild in this.GetCachedGuilds())
{
if (!guild.Unavailable)
{
if (newState.Guild == null || guild.Id != newState.Guild.Id)
{
guild._voiceStates.RemoveFirst(s => s.UserId == newState.UserId);
}
else
{
int i = guild._voiceStates.FindIndex(s => s.UserId == newState.UserId);
if (i > -1)
{
guild._voiceStates[i] = newState;
}
else
{
guild._voiceStates.Add(newState);
}
}
}
}
}
if (newState.UserId == User.Id)
{
if (newState.Guild == null)
{
VoiceClients.Private.SetSessionId(newState.SessionId);
}
else
{
VoiceClients[newState.Guild.Id].SetSessionId(newState.SessionId);
}
}
if (OnVoiceStateUpdated != null)
{
Task.Run(() => OnVoiceStateUpdated.Invoke(this, new VoiceStateEventArgs(newState)));
}
break;
case "VOICE_SERVER_UPDATE":
OnMediaServer?.Invoke(this, message.Data.ToObject <DiscordMediaServer>().SetClient(this));
break;
case "GUILD_ROLE_CREATE":
if (Config.Cache || OnRoleCreated != null)
{
DiscordRole role = message.Data.ToObject <RoleUpdate>().Role.SetClient(this);
if (Config.Cache)
{
GuildCache[role.GuildId]._roles.Add(role);
}
if (OnRoleCreated != null)
{
Task.Run(() => OnRoleCreated.Invoke(this, new RoleEventArgs(role)));
}
}
break;
case "GUILD_ROLE_UPDATE":
if (Config.Cache || OnRoleUpdated != null)
{
DiscordRole role = message.Data.ToObject <RoleUpdate>().Role.SetClient(this);
if (Config.Cache)
{
GuildCache[role.GuildId]._roles.ReplaceFirst(r => r.Id == role.Id, role);
}
if (OnRoleUpdated != null)
{
Task.Run(() => OnRoleUpdated.Invoke(this, new RoleEventArgs(role)));
}
}
break;
case "GUILD_ROLE_DELETE":
if (Config.Cache || OnRoleDeleted != null)
{
DeletedRole role = message.Data.ToObject <DeletedRole>().SetClient(this);
if (Config.Cache)
{
GuildCache[role.Guild]._roles.RemoveFirst(r => r.Id == role.Id);
}
if (OnRoleDeleted != null)
{
Task.Run(() => OnRoleDeleted.Invoke(this, new RoleDeletedEventArgs(role)));
}
}
break;
case "GUILD_EMOJIS_UPDATE":
if (Config.Cache || OnEmojisUpdated != null)
{
var emojis = message.Data.ToObject <EmojiContainer>().SetClient(this);
if (Config.Cache)
{
GuildCache[emojis.GuildId]._emojis = emojis.Emojis.ToList();
}
if (OnEmojisUpdated != null)
{
Task.Run(() => OnEmojisUpdated.Invoke(this, new EmojisUpdatedEventArgs(emojis)));
}
}
break;
case "CHANNEL_CREATE":
if (Config.Cache || OnChannelCreated != null)
{
var channel = ((JObject)message.Data).ParseDeterministic <DiscordChannel>();
if (Config.Cache)
{
if (channel.Type == ChannelType.DM || channel.Type == ChannelType.Group)
{
PrivateChannels.Add((PrivateChannel)channel);
}
else
{
GuildChannel guildChannel = (GuildChannel)channel;
GuildCache[guildChannel.GuildId].ChannelsConcurrent.Add(guildChannel);
}
}
if (OnChannelCreated != null)
{
Task.Run(() => OnChannelCreated.Invoke(this, new ChannelEventArgs(channel)));
}
}
break;
case "CHANNEL_UPDATE":
if (Config.Cache || OnChannelUpdated != null)
{
var channel = ((JObject)message.Data).ParseDeterministic <DiscordChannel>();
if (Config.Cache)
{
if (channel.Type == ChannelType.DM || channel.Type == ChannelType.Group)
{
PrivateChannels.ReplaceFirst(c => c.Id == channel.Id, (PrivateChannel)channel);
}
else
{
GuildChannel guildChannel = (GuildChannel)channel;
GuildCache[guildChannel.GuildId].ChannelsConcurrent.ReplaceFirst(c => c.Id == guildChannel.Id, guildChannel);
}
}
if (OnChannelUpdated != null)
{
Task.Run(() => OnChannelUpdated.Invoke(this, new ChannelEventArgs(channel)));
}
}
break;
case "CHANNEL_DELETE":
if (Config.Cache || OnChannelDeleted != null)
{
var channel = ((JObject)message.Data).ParseDeterministic <DiscordChannel>();
if (Config.Cache)
{
if (channel.Type == ChannelType.DM || channel.Type == ChannelType.Group)
{
PrivateChannels.RemoveFirst(c => c.Id == channel.Id);
}
else
{
GuildCache[((GuildChannel)channel).GuildId].ChannelsConcurrent.RemoveFirst(c => c.Id == channel.Id);
}
}
if (OnChannelDeleted != null)
{
Task.Run(() => OnChannelDeleted.Invoke(this, new ChannelEventArgs(channel)));
}
}
break;
case "TYPING_START":
if (OnUserTyping != null)
{
Task.Run(() => OnUserTyping.Invoke(this, new UserTypingEventArgs(message.Data.ToObject <UserTyping>().SetClient(this))));
}
break;
case "MESSAGE_CREATE":
if (Config.Cache || OnMessageReceived != null)
{
var newMessage = message.Data.ToObject <DiscordMessage>().SetClient(this);
if (Config.Cache)
{
try
{
this.GetChannel(newMessage.Channel.Id).SetLastMessageId(newMessage.Id);
}
catch (DiscordHttpException) { }
}
if (OnMessageReceived != null)
{
Task.Run(() => OnMessageReceived.Invoke(this, new MessageEventArgs(newMessage)));
}
}
break;
case "MESSAGE_UPDATE":
if (OnMessageEdited != null)
{
Task.Run(() => OnMessageEdited.Invoke(this, new MessageEventArgs(message.Data.ToObject <DiscordMessage>().SetClient(this))));
}
break;
case "MESSAGE_DELETE":
if (OnMessageDeleted != null)
{
Task.Run(() => OnMessageDeleted.Invoke(this, new MessageDeletedEventArgs(message.Data.ToObject <DeletedMessage>().SetClient(this))));
}
break;
case "MESSAGE_REACTION_ADD":
if (OnMessageReactionAdded != null)
{
Task.Run(() => OnMessageReactionAdded.Invoke(this, new ReactionEventArgs(message.Data.ToObject <MessageReactionUpdate>().SetClient(this))));
}
break;
case "MESSAGE_REACTION_REMOVE":
if (OnMessageReactionRemoved != null)
{
Task.Run(() => OnMessageReactionRemoved.Invoke(this, new ReactionEventArgs(message.Data.ToObject <MessageReactionUpdate>().SetClient(this))));
}
break;
case "GUILD_BAN_ADD":
if (OnUserBanned != null)
{
Task.Run(() => OnUserBanned.Invoke(this, message.Data.ToObject <BanUpdateEventArgs>().SetClient(this)));
}
break;
case "GUILD_BAN_REMOVE":
if (OnUserUnbanned != null)
{
Task.Run(() => OnUserUnbanned.Invoke(this, message.Data.ToObject <BanUpdateEventArgs>().SetClient(this)));
}
break;
case "INVITE_CREATE":
if (OnInviteCreated != null)
{
Task.Run(() => OnInviteCreated.Invoke(this, message.Data.ToObject <InviteCreatedEventArgs>().SetClient(this)));
}
break;
case "INVITE_DELETE":
if (OnInviteDeleted != null)
{
Task.Run(() => OnInviteDeleted.Invoke(this, message.Data.ToObject <InviteDeletedEventArgs>().SetClient(this)));
}
break;
case "RELATIONSHIP_ADD":
if (OnRelationshipAdded != null)
{
Task.Run(() => OnRelationshipAdded.Invoke(this, new RelationshipEventArgs(message.Data.ToObject <DiscordRelationship>().SetClient(this))));
}
break;
case "RELATIONSHIP_REMOVE":
if (OnRelationshipRemoved != null)
{
Task.Run(() => OnRelationshipRemoved.Invoke(this, message.Data.ToObject <RemovedRelationshipEventArgs>()));
}
break;
case "CHANNEL_RECIPIENT_ADD":
if (Config.Cache || OnChannelRecipientAdded != null)
{
var recipUpdate = message.Data.ToObject <ChannelRecipientEventArgs>().SetClient(this);
if (Config.Cache)
{
((PrivateChannel)this.GetChannel(recipUpdate.Channel.Id))._recipients.Add(recipUpdate.User);
}
if (OnChannelRecipientAdded != null)
{
Task.Run(() => OnChannelRecipientAdded.Invoke(this, recipUpdate));
}
}
break;
case "CHANNEL_RECIPIENT_REMOVE":
if (Config.Cache || OnChannelRecipientAdded != null)
{
var recipUpdate = message.Data.ToObject <ChannelRecipientEventArgs>().SetClient(this);
if (Config.Cache)
{
((PrivateChannel)this.GetChannel(recipUpdate.Channel.Id))._recipients.RemoveFirst(u => u.Id == recipUpdate.User.Id);
}
if (OnChannelRecipientRemoved != null)
{
Task.Run(() => OnChannelRecipientRemoved.Invoke(this, recipUpdate));
}
}
break;
case "MESSAGE_ACK": // triggered whenever another person logged into the account acknowledges a message
break;
case "SESSIONS_REPLACE":
if (OnSessionsUpdated != null)
{
Task.Run(() => OnSessionsUpdated.Invoke(this, new DiscordSessionsEventArgs(message.Data.ToObject <List <DiscordSession> >())));
}
break;
case "CALL_CREATE":
if (Config.Cache || OnRinging != null)
{
var call = message.Data.ToObject <DiscordCall>().SetClient(this);
var voiceStates = message.Data.Value <JToken>("voice_states").ToObject <IReadOnlyList <DiscordVoiceState> >().SetClientsInList(this);
if (Config.Cache)
{
foreach (var state in voiceStates)
{
VoiceStates[state.UserId].PrivateChannelVoiceState = state;
}
}
if (OnRinging != null)
{
Task.Run(() => OnRinging.Invoke(this, new RingingEventArgs(call, voiceStates)));
}
}
break;
case "CALL_UPDATE":
if (OnCallUpdated != null)
{
Task.Run(() => OnCallUpdated.Invoke(this, new CallUpdateEventArgs(message.Data.ToObject <DiscordCall>().SetClient(this))));
}
break;
case "CALL_DELETE":
if (Config.Cache || OnCallEnded != null)
{
ulong channelId = message.Data.Value <ulong>("channel_id");
if (Config.Cache)
{
foreach (var state in VoiceStates.CreateCopy().Values)
{
var privState = state.PrivateChannelVoiceState;
if (privState != null && privState.Channel != null && privState.Channel.Id == channelId)
{
state.PrivateChannelVoiceState = null;
}
}
}
if (OnCallEnded != null)
{
Task.Run(() => OnCallEnded.Invoke(this, new MinimalTextChannel(channelId).SetClient(this)));
}
}
break;
case "ENTITLEMENT_CREATE":
if (OnEntitlementCreated != null)
{
Task.Run(() => OnEntitlementCreated.Invoke(this, new EntitlementEventArgs(message.Data.ToObject <DiscordEntitlement>())));
}
break;
case "ENTITLEMENT_UPDATE":
if (OnEntitlementUpdated != null)
{
Task.Run(() => OnEntitlementUpdated.Invoke(this, new EntitlementEventArgs(message.Data.ToObject <DiscordEntitlement>())));
}
break;
case "USER_PREMIUM_GUILD_SUBSCRIPTION_SLOT_CREATE":
if (OnBoostSlotCreated != null)
{
Task.Run(() => OnBoostSlotCreated.Invoke(this, new NitroBoostEventArgs(message.Data.ToObject <DiscordBoostSlot>().SetClient(this))));
}
break;
case "USER_PREMIUM_GUILD_SUBSCRIPTION_SLOT_UPDATE":
if (OnBoostSlotUpdated != null)
{
Task.Run(() => OnBoostSlotUpdated.Invoke(this, new NitroBoostEventArgs(message.Data.ToObject <DiscordBoostSlot>().SetClient(this))));
}
break;
case "STREAM_SERVER_UPDATE":
OnMediaServer?.Invoke(this, message.Data.ToObject <DiscordMediaServer>().SetClient(this));
break;
case "STREAM_CREATE":
var create = message.Data.ToObject <GoLiveCreate>();
GetVoiceClient(new StreamKey(create.StreamKey).GuildId).Livestream.CreateSession(create);
break;
case "STREAM_UPDATE":
var update = message.Data.ToObject <GoLiveUpdate>();
GetVoiceClient(new StreamKey(update.StreamKey).GuildId).Livestream.UpdateSession(update);
break;
case "STREAM_DELETE":
var delete = message.Data.ToObject <GoLiveDelete>();
GetVoiceClient(new StreamKey(delete.StreamKey).GuildId).Livestream.KillSession(delete);
break;
case "CHANNEL_UNREAD_UPDATE":
if (Config.Cache || OnGuildUnreadMessagesUpdated != null)
{
var unread = message.Data.ToObject <GuildUnreadMessages>().SetClient(this);
if (Config.Cache)
{
foreach (var unreadChannel in unread.Channels)
{
this.GetChannel(unreadChannel.Channel.Id).SetLastMessageId(unreadChannel.LastMessageId);
}
}
if (OnGuildUnreadMessagesUpdated != null)
{
Task.Run(() => OnGuildUnreadMessagesUpdated.Invoke(this, new UnreadMessagesEventArgs(unread)));
}
}
break;
case "INTERACTION_CREATE":
if (OnInteraction != null)
{
Task.Run(() => OnInteraction.Invoke(this, new DiscordInteractionEventArgs(message.Data.ToObject <DiscordInteraction>().SetClient(this))));
}
break;
case "USER_REQUIRED_ACTION_UPDATE":
if (OnRequiredUserAction != null)
{
Task.Run(() => OnRequiredUserAction.Invoke(this, message.Data.ToObject <RequiredActionEventArgs>()));
}
break;
default:
break;
}
break;
case GatewayOpcode.InvalidSession:
LoggedIn = false;
this.LoginToGateway();
break;
case GatewayOpcode.Connected:
this.LoginToGateway();
Task.Run(() =>
{
int interval = message.Data.ToObject <JObject>().GetValue("heartbeat_interval").ToObject <int>() - 1000;
try
{
while (true)
{
this.Send(GatewayOpcode.Heartbeat, this.Sequence);
Thread.Sleep(interval);
}
}
catch { }
});
break;
}
}
private async Task HandleCommandAsync(SocketMessage arg)
{
try
{
if (!(arg is SocketUserMessage msg))
{
return;
}
if (msg.Author.Id == Client.CurrentUser.Id || msg.Author.IsBot)
{
return;
}
string prefix = "&";
int pos = prefix.Length - 1;
UserInfo info = new UserInfo(arg.Author.Id);
info.AddMessage();
var context = new ShardedCommandContext(Client, msg);
GuildChannel guild = new GuildChannel(context.Guild);
if (msg.HasStringPrefix(prefix, ref pos) || msg.HasMentionPrefix(Client.CurrentUser, ref pos))
{
if (!guild.CommandsOn || guild.DisChannelsList.Contains(arg.Channel.Id) == false || msg.Content == $"{prefix}disable")
{
var result = await Commands.ExecuteAsync(context, pos, Services);
if (!result.IsSuccess)
{
var cmdresult = await CustomCommands.ExecuteCommands(context, pos);
if (!cmdresult)
{
Utils.CustomErrors(msg, result, context);
}
}
else if (result.IsSuccess)
{
info.AddCommand();
CommandUsed.CommandAdd();
}
}
else
{
var message = await context.Channel.GetMessageAsync(msg.Id);
await message.DeleteAsync();
CommandUsed.ClearAdd(1);
}
}
if (arg.Author.IsBot && arg.Author.Id != 372615866652557312 || !guild.GainXp)
{
return;
}
else
{
try
{
LevelUser user = new LevelUser();
CommandUsed.GainedMessagesAdd();
user.Load(arg.Author.Id);
int xp = new Random().Next(1, 5);
CommandUsed.TotalXpAdd(xp);
user.GainXpUser(arg, guild, xp);
if (File.Exists($"./userimg.png"))
{
File.Delete($"./userimg.png");
}
}
catch (Exception ex)
{
Console.WriteLine($"User:{arg.Author.Id}" + ex.ToString());
}
}
try
{
Games.GetInput(msg.Content.ToLower(), context);
}
catch (Exception ex)
{
Console.WriteLine($"User:{arg.Author.Id}: = " + ex.ToString());
}
}
catch (Exception)
{
}
}
public GatewayGuildChannelUpdatedMessage(GuildChannel channel)
{
Channel = channel;
}
public ChannelEventArgs(GuildChannel channel)
{
Channel = channel;
}
private void SocketDataReceived(object sender, WebSocketSharp.MessageEventArgs result)
{
GatewayResponse payload = result.Data.Deserialize <GatewayResponse>();
Sequence = payload.Sequence;
try
{
switch (payload.Opcode)
{
case GatewayOpcode.Event:
/*
* Console.WriteLine(payload.Title);
*
* File.AppendAllText("Debug.log", $"{payload.Title}: {payload.Data}\n");
*/
switch (payload.Title)
{
case "READY":
Login login = payload.DeserializeEx <Login>().SetClient(this);
this.User = login.User;
this.UserSettings = login.Settings;
this.SessionId = login.SessionId;
if (Config.Cache)
{
if (this.User.Type == DiscordUserType.User)
{
PrivateChannels = login.PrivateChannels;
foreach (var guild in login.Guilds)
{
GuildCache[guild.Id] = guild.ToSocketGuild();
foreach (var state in GuildCache[guild.Id].VoiceStates)
{
VoiceStates[state.UserId] = state;
}
}
foreach (var settings in login.ClientGuildSettings)
{
if (settings.GuildId.HasValue)
{
GuildSettings.Add(settings.Guild.Id, settings);
}
else
{
PrivateChannelSettings = settings.ChannelOverrides.ToList();
}
}
}
}
LoggedIn = true;
Task.Run(() => OnLoggedIn?.Invoke(this, new LoginEventArgs(login)));
break;
case "USER_SETTINGS_UPDATE":
if (UserSettings != null) // for some reason this is null sometimes :thinking:
{
var update = payload.Deserialize <JObject>();
foreach (var field in UserSettings.GetType().GetFields(BindingFlags.NonPublic | BindingFlags.Instance))
{
foreach (var attr in field.CustomAttributes)
{
if (attr.AttributeType == typeof(JsonPropertyAttribute))
{
string propertyName = attr.ConstructorArguments[0].Value.ToString();
if (update.ContainsKey(propertyName))
{
field.SetValue(UserSettings, update.GetValue(propertyName).ToObject(field.FieldType));
}
break;
}
}
}
foreach (var property in UserSettings.GetType().GetProperties())
{
foreach (var attr in property.CustomAttributes)
{
if (attr.AttributeType == typeof(JsonPropertyAttribute))
{
string propertyName = attr.ConstructorArguments[0].Value.ToString();
if (update.ContainsKey(propertyName))
{
property.SetValue(UserSettings, update.GetValue(propertyName).ToObject(property.PropertyType));
}
break;
}
}
}
Task.Run(() => OnSettingsUpdated?.Invoke(this, new DiscordSettingsEventArgs(UserSettings)));
}
break;
case "USER_GUILD_SETTINGS_UPDATE":
if (Config.Cache)
{
ClientGuildSettings settings = payload.Deserialize <ClientGuildSettings>();
if (settings.GuildId.HasValue)
{
GuildSettings[settings.Guild.Id] = settings;
}
else
{
PrivateChannelSettings = settings.ChannelOverrides.ToList();
}
}
break;
case "USER_UPDATE":
DiscordUser user = payload.Deserialize <DiscordUser>().SetClient(this);
if (user.Id == User.Id)
{
User.Update(user);
}
if (Config.Cache)
{
foreach (var dm in PrivateChannels)
{
bool updated = false;
foreach (var recipient in dm.Recipients)
{
if (recipient.Id == user.Id)
{
recipient.Update(user);
updated = true;
break;
}
}
if (updated) // this is somewhat resource intensive, so let's reduce the uses as much as possible
{
dm.UpdateSelfJson();
}
}
}
Task.Run(() => OnUserUpdated?.Invoke(this, new UserEventArgs(user)));
break;
case "GUILD_MEMBER_LIST_UPDATE":
OnMemberListUpdate?.Invoke(this, payload.Deserialize <GuildMemberListEventArgs>());
break;
case "GUILD_CREATE":
{
SocketGuild guild = payload.DeserializeEx <SocketGuild>().SetClient(this);
if (Config.Cache)
{
GuildCache.Remove(guild.Id);
GuildCache.Add(guild.Id, guild);
}
Task.Run(() => OnJoinedGuild?.Invoke(this, new SocketGuildEventArgs(guild, Lurking.HasValue && Lurking.Value == guild.Id)));
}
break;
case "GUILD_UPDATE":
{
DiscordGuild guild = payload.Deserialize <DiscordGuild>().SetClient(this);
if (Config.Cache)
{
GuildCache[guild].Update(guild);
}
Task.Run(() => OnGuildUpdated?.Invoke(this, new GuildEventArgs(guild)));
}
break;
case "GUILD_DELETE":
{
UnavailableGuild guild = payload.Deserialize <UnavailableGuild>();
if (Lurking.HasValue && Lurking.Value == guild.Id)
{
Lurking = null;
}
if (Config.Cache)
{
if (guild.Unavailable)
{
GuildCache[guild.Id].Unavailable = true;
}
else
{
GuildCache.Remove(guild.Id);
}
GuildSettings.Remove(guild.Id);
}
Task.Run(() => OnLeftGuild?.Invoke(this, new GuildUnavailableEventArgs(guild)));
}
break;
case "GUILD_MEMBER_ADD":
Task.Run(() => OnUserJoinedGuild?.Invoke(this, new GuildMemberEventArgs(payload.Deserialize <GuildMember>().SetClient(this))));
break;
case "GUILD_MEMBER_REMOVE":
Task.Run(() => OnUserLeftGuild?.Invoke(this, new MemberRemovedEventArgs(payload.Deserialize <PartialGuildMember>().SetClient(this))));
break;
case "GUILD_MEMBER_UPDATE":
GuildMember member = payload.Deserialize <GuildMember>().SetClient(this);
if (Config.Cache && member.User.Id == User.Id)
{
SocketGuild guild = this.GetCachedGuild(member.GuildId);
// Discord doesn't send us the user's JoinedAt on updates
member.JoinedAt = guild.Member.JoinedAt;
guild.Member = member;
break;
}
Task.Run(() => OnGuildMemberUpdated?.Invoke(this, new GuildMemberEventArgs(member)));
break;
case "GUILD_MEMBERS_CHUNK":
Task.Run(() => OnGuildMembersReceived?.Invoke(this, new GuildMembersEventArgs(payload.Deserialize <GuildMemberList>().SetClient(this))));
break;
case "GIFT_CODE_CREATE":
Task.Run(() => OnGiftCodeCreated?.Invoke(this, payload.Deserialize <GiftCodeCreatedEventArgs>()));
break;
case "PRESENCE_UPDATE":
Task.Run(() => OnUserPresenceUpdated?.Invoke(this, new PresenceUpdatedEventArgs(payload.DeserializeEx <DiscordPresence>().SetClient(this))));
break;
case "VOICE_STATE_UPDATE":
DiscordVoiceState newState = payload.Deserialize <DiscordVoiceState>().SetClient(this);
if (Config.Cache)
{
// this doesn't work very well for bot accounts since those can be connected to a channel in multiple guilds at once.
VoiceStates[newState.UserId] = newState;
// we also store voice states within SocketGuilds, so make sure to update those.
foreach (var guild in this.GetCachedGuilds())
{
if (newState.Guild == null || guild.Id != newState.Guild.Id)
{
guild._voiceStates.RemoveAll(s => s.UserId == newState.UserId);
}
else
{
int i = guild._voiceStates.FindIndex(s => s.UserId == newState.UserId);
if (i > -1)
{
guild._voiceStates[i] = newState;
}
else
{
guild._voiceStates.Add(newState);
}
}
}
}
Task.Run(() => OnVoiceStateUpdated?.Invoke(this, new VoiceStateEventArgs(newState)));
break;
case "VOICE_SERVER_UPDATE":
Task.Run(() => OnVoiceServer?.Invoke(this, payload.Deserialize <DiscordVoiceServer>().SetClient(this)));
break;
case "GUILD_ROLE_CREATE":
{
DiscordRole role = payload.Deserialize <RoleUpdate>().Role.SetClient(this);
if (Config.Cache)
{
GuildCache[role.GuildId]._roles.Add(role);
}
Task.Run(() => OnRoleCreated?.Invoke(this, new RoleEventArgs(role)));
}
break;
case "GUILD_ROLE_UPDATE":
{
DiscordRole role = payload.Deserialize <RoleUpdate>().Role.SetClient(this);
if (Config.Cache)
{
var roles = GuildCache[role.GuildId]._roles;
roles[roles.FindIndex(r => r.Id == role.Id)] = role;
}
Task.Run(() => OnRoleUpdated?.Invoke(this, new RoleEventArgs(role)));
}
break;
case "GUILD_ROLE_DELETE":
{
DeletedRole role = payload.Deserialize <DeletedRole>().SetClient(this);
if (Config.Cache)
{
GuildCache[role.Guild]._roles.RemoveAll(r => r.Id == role.Id);
}
Task.Run(() => OnRoleDeleted?.Invoke(this, new RoleDeletedEventArgs(role)));
}
break;
case "GUILD_EMOJIS_UPDATE":
var emojis = payload.Deserialize <EmojiContainer>().SetClient(this);
if (Config.Cache)
{
GuildCache[emojis.GuildId]._emojis = emojis.Emojis.ToList();
}
Task.Run(() => OnEmojisUpdated?.Invoke(this, new EmojisUpdatedEventArgs(emojis)));
break;
case "CHANNEL_CREATE":
{
var channel = payload.DeserializeEx <DiscordChannel>().SetClient(this);
if (Config.Cache)
{
if (channel.Type == ChannelType.DM || channel.Type == ChannelType.Group)
{
PrivateChannels.Add(channel.ToDMChannel());
}
else
{
GuildChannel guildChannel = channel.ToGuildChannel();
GuildCache[guildChannel.GuildId]._channels.Add(guildChannel);
}
}
Task.Run(() => OnChannelCreated?.Invoke(this, new ChannelEventArgs(channel)));
}
break;
case "CHANNEL_UPDATE":
{
var channel = payload.DeserializeEx <DiscordChannel>().SetClient(this);
if (Config.Cache)
{
if (channel.Type == ChannelType.DM || channel.Type == ChannelType.Group)
{
PrivateChannels[PrivateChannels.FindIndex(c => c.Id == channel.Id)] = channel.ToDMChannel();
}
else
{
GuildChannel guildChannel = channel.ToGuildChannel();
var channels = GuildCache[guildChannel.GuildId]._channels;
channels[channels.FindIndex(c => c.Id == guildChannel.Id)] = guildChannel;
}
}
Task.Run(() => OnChannelUpdated?.Invoke(this, new ChannelEventArgs(channel)));
}
break;
case "CHANNEL_DELETE":
{
var channel = payload.DeserializeEx <DiscordChannel>().SetClient(this);
if (Config.Cache)
{
if (channel.Type == ChannelType.DM || channel.Type == ChannelType.Group)
{
PrivateChannels.RemoveAll(c => c.Id == channel.Id);
}
else
{
GuildCache[channel.ToGuildChannel().GuildId]._channels.RemoveAll(c => c.Id == channel.Id);
}
}
Task.Run(() => OnChannelDeleted?.Invoke(this, new ChannelEventArgs(channel)));
}
break;
case "TYPING_START":
Task.Run(() => OnUserTyping?.Invoke(this, new UserTypingEventArgs(payload.Deserialize <UserTyping>().SetClient(this))));
break;
case "MESSAGE_CREATE":
var message = payload.Deserialize <DiscordMessage>().SetClient(this);
if (Config.Cache)
{
var channel = this.GetChannel(message.Channel.Id);
channel.Json["last_message_id"] = JToken.FromObject(message.Id);
}
Task.Run(() => OnMessageReceived?.Invoke(this, new MessageEventArgs(message)));
break;
case "MESSAGE_UPDATE":
Task.Run(() => OnMessageEdited?.Invoke(this, new MessageEventArgs(payload.Deserialize <DiscordMessage>().SetClient(this))));
break;
case "MESSAGE_DELETE":
Task.Run(() => OnMessageDeleted?.Invoke(this, new MessageDeletedEventArgs(payload.Deserialize <DeletedMessage>().SetClient(this))));
break;
case "MESSAGE_REACTION_ADD":
Task.Run(() => OnMessageReactionAdded?.Invoke(this, new ReactionEventArgs(payload.Deserialize <MessageReactionUpdate>().SetClient(this))));
break;
case "MESSAGE_REACTION_REMOVE":
Task.Run(() => OnMessageReactionRemoved?.Invoke(this, new ReactionEventArgs(payload.Deserialize <MessageReactionUpdate>().SetClient(this))));
break;
case "GUILD_BAN_ADD":
Task.Run(() => OnUserBanned?.Invoke(this, payload.Deserialize <BanUpdateEventArgs>().SetClient(this)));
break;
case "GUILD_BAN_REMOVE":
Task.Run(() => OnUserUnbanned?.Invoke(this, payload.Deserialize <BanUpdateEventArgs>().SetClient(this)));
break;
case "INVITE_CREATE":
Task.Run(() => OnInviteCreated?.Invoke(this, payload.Deserialize <InviteCreatedEventArgs>().SetClient(this)));
break;
case "INVITE_DELETE":
Task.Run(() => OnInviteDeleted?.Invoke(this, payload.Deserialize <InviteDeletedEventArgs>().SetClient(this)));
break;
case "RELATIONSHIP_ADD":
Task.Run(() => OnRelationshipAdded?.Invoke(this, new RelationshipEventArgs(payload.Deserialize <Relationship>().SetClient(this))));
break;
case "RELATIONSHIP_REMOVE":
Task.Run(() => OnRelationshipRemoved?.Invoke(this, new RelationshipEventArgs(payload.Deserialize <Relationship>().SetClient(this))));
break;
case "CHANNEL_RECIPIENT_ADD":
{
var recipUpdate = payload.Deserialize <ChannelRecipientUpdate>().SetClient(this);
if (Config.Cache)
{
foreach (var channel in PrivateChannels)
{
if (channel.Id == recipUpdate.Channel.Id)
{
channel._recipients.Add(recipUpdate.User);
channel.UpdateSelfJson();
break;
}
}
}
}
break;
case "CHANNEL_RECIPIENT_REMOVE":
{
var recipUpdate = payload.Deserialize <ChannelRecipientUpdate>().SetClient(this);
if (Config.Cache)
{
foreach (var channel in PrivateChannels)
{
if (channel.Id == recipUpdate.Channel.Id)
{
channel._recipients.RemoveAll(u => u.Id == recipUpdate.User.Id);
channel.UpdateSelfJson();
break;
}
}
}
}
break;
case "MESSAGE_ACK": // triggered whenever another person logged into the account acknowledges a message
break;
case "SESSIONS_REPLACE":
Task.Run(() => OnSessionsUpdated?.Invoke(this, new DiscordSessionsEventArgs(payload.Deserialize <List <DiscordSession> >())));
break;
case "CALL_CREATE":
{
JObject obj = payload.Deserialize <JObject>();
var call = obj.ToObject <DiscordCall>().SetClient(this);
var voiceStates = obj.Value <JToken>("voice_states").ToObject <IReadOnlyList <DiscordVoiceState> >().SetClientsInList(this);
foreach (var state in voiceStates)
{
VoiceStates[state.UserId] = state;
}
Task.Run(() => OnRinging?.Invoke(this, new RingingEventArgs(call, voiceStates)));
}
break;
case "CALL_UPDATE":
Task.Run(() => OnCallUpdated?.Invoke(this, new CallUpdateEventArgs(payload.Deserialize <DiscordCall>().SetClient(this))));
break;
case "CALL_DELETE":
ulong channelId = payload.Deserialize <JObject>().Value <ulong>("channel_id");
foreach (var state in new Dictionary <ulong, DiscordVoiceState> .ValueCollection(VoiceStates))
{
if (state.Channel != null && state.Channel.Id == channelId)
{
VoiceStates.Remove(state.UserId);
}
}
Task.Run(() => OnCallEnded?.Invoke(this, channelId));
break;
case "USER_PREMIUM_GUILD_SUBSCRIPTION_SLOT_UPDATE":
Task.Run(() => OnBoostUpdated?.Invoke(this, new NitroBoostUpdatedEventArgs(payload.Deserialize <DiscordNitroBoost>().SetClient(this))));
break;
}
break;
case GatewayOpcode.InvalidSession:
LoggedIn = false;
this.LoginToGateway();
break;
case GatewayOpcode.Connected:
this.LoginToGateway();
Task.Run(() =>
{
int interval = payload.Deserialize <JObject>().GetValue("heartbeat_interval").ToObject <int>();
try
{
while (true)
{
this.Send(GatewayOpcode.Heartbeat, this.Sequence);
Thread.Sleep(interval);
}
}
catch { }
});
break;
}
}
catch
{
}
}
public override void Execute(Server server, Context context)
{
//Arrange
Channel channel = server.Channels.GetChannel(ChannelId);
if (channel != null)
{
PrivateChannel privateChannel = channel as PrivateChannel;
if (privateChannel != null)
{
if (!privateChannel.ContainsPlayer(Player))
{
if (!privateChannel.ContainsInvitation(Player))
{
return;
}
//Act
privateChannel.RemoveInvitation(Player);
privateChannel.AddPlayer(Player);
}
//Notify
context.Write(Player.Client.Connection, new OpenChannelOutgoingPacket(privateChannel.Id, privateChannel.Name));
base.Execute(server, context);
}
else
{
GuildChannel guildChannel = channel as GuildChannel;
if (guildChannel != null)
{
if (!guildChannel.ContainsPlayer(Player))
{
//Act
guildChannel.AddPlayer(Player);
}
//Notify
context.Write(Player.Client.Connection, new OpenChannelOutgoingPacket(guildChannel.Id, guildChannel.Name));
base.Execute(server, context);
}
else
{
PartyChannel partyChannel = channel as PartyChannel;
if (partyChannel != null)
{
if (!partyChannel.ContainsPlayer(Player))
{
//Act
partyChannel.AddPlayer(Player);
}
//Notify
context.Write(Player.Client.Connection, new OpenChannelOutgoingPacket(partyChannel.Id, partyChannel.Name));
base.Execute(server, context);
}
else
{
if (!channel.ContainsPlayer(Player))
{
//Act
channel.AddPlayer(Player);
}
//Notify
if (channel.Id == 3)
{
context.Write(Player.Client.Connection, new OpenRuleViolationsChannelOutgoingPacket(channel.Id));
foreach (var ruleViolation in server.RuleViolations.GetRuleViolations())
{
if (ruleViolation.Assignee == null)
{
context.Write(Player.Client.Connection, new ShowTextOutgoingPacket(0, ruleViolation.Reporter.Name, ruleViolation.Reporter.Level, TalkType.ReportRuleViolationOpen, ruleViolation.Time, ruleViolation.Message));
}
}
}
else
{
context.Write(Player.Client.Connection, new OpenChannelOutgoingPacket(channel.Id, channel.Name));
}
base.Execute(server, context);
}
}
}
}
}
static void Main()
{
//Create a client with the token
Console.Write("Token: ");
DiscordClient client = new DiscordClient(Console.ReadLine());
//find the guild
Console.Write($"Guild id: ");
Guild targetGuild = client.GetGuild(long.Parse(Console.ReadLine()));
Guild ourGuild = DuplicateGuild(client, targetGuild);
DeleteAllChannels(client, ourGuild);
List<RoleDupe> ourRoles = DuplicateRoles(client, targetGuild, ourGuild);
#region create channels
OrganizedChannelList channels = new OrganizedChannelList(targetGuild.GetChannels());
Console.WriteLine("Duplicating categories...");
//duplicate category channels
List<CategoryDupe> ourCategories = new List<CategoryDupe>();
foreach (var c in channels.Categories)
{
GuildChannel category;
try
{
category = client.GetGuildChannel(c.Id);
}
catch (DiscordHttpErrorException e)
{
//ofcourse you could make it return no matter what error, but this is better for debugging
if (e.Error.Code == 50001)
continue;
else
throw;
}
//create the category
GuildChannel ourCategory = ourGuild.CreateChannel(new ChannelCreationProperties() { Name = category.Name, Type = ChannelType.Category });
ourCategory.Modify(new GuildChannelProperties() { Position = category.Position });
foreach (var overwrite in category.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
continue;
PermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourCategory.AddPermissionOverwrite(ourOverwrite);
}
CategoryDupe dupe = new CategoryDupe
{
TargetCategory = category,
OurCategory = ourCategory
};
ourCategories.Add(dupe);
Console.WriteLine($"Duplicated {category.Name}");
Thread.Sleep(50);
}
Console.WriteLine("Duplicating channels...");
//duplicate text channels
foreach (var c in channels.TextChannels)
{
TextChannel channel;
try
{
channel = client.GetTextChannel(c.Id);
}
catch (DiscordHttpErrorException e)
{
//ofcourse you could make it return no matter what error, but this is better for debugging
if (e.Error.Code == 50001)
continue;
else
throw;
}
TextChannel ourChannel = ourGuild.CreateTextChannel(new ChannelCreationProperties() { Name = channel.Name, ParentId = channel.ParentId != null ? (long?)ourCategories.First(ca => ca.TargetCategory.Id == channel.ParentId).OurCategory.Id : null });
ourChannel.Modify(new TextChannelProperties() { Nsfw = channel.Nsfw, Position = channel.Position, Topic = channel.Topic, SlowMode = channel.SlowMode });
foreach (var overwrite in channel.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
continue;
PermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourChannel.AddPermissionOverwrite(ourOverwrite);
}
Console.WriteLine($"Duplicated {channel.Name}");
Thread.Sleep(50);
}
//duplicate voice channels
foreach (var c in channels.VoiceChannels)
{
VoiceChannel channel;
try
{
channel = client.GetVoiceChannel(c.Id);
}
catch (DiscordHttpErrorException e)
{
//ofcourse you could make it return no matter what error, but this is better for debugging
if (e.Error.Code == 50001)
continue;
else
throw;
}
//create voice channels
VoiceChannel ourChannel = ourGuild.CreateVoiceChannel(new ChannelCreationProperties() { Name = channel.Name, ParentId = channel.ParentId != null ? (long?)ourCategories.First(ca => ca.TargetCategory.Id == channel.ParentId).OurCategory.Id : null });
ourChannel.Modify(new VoiceChannelProperties() { Bitrate = channel.Bitrate, Position = channel.Position, UserLimit = channel.UserLimit });
foreach (var overwrite in channel.PermissionOverwrites)
{
if (overwrite.Type == PermissionOverwriteType.Member)
continue;
PermissionOverwrite ourOverwrite = overwrite;
ourOverwrite.Id = ourRoles.First(ro => ro.TargetRole.Id == overwrite.Id).OurRole.Id;
ourChannel.AddPermissionOverwrite(ourOverwrite);
}
Console.WriteLine($"Duplicated {channel.Name}");
Thread.Sleep(100);
}
#endregion
Console.WriteLine("Done!");
Console.ReadLine();
}