public static bool DeleteChannel(Player player, ushort channelId)
{
switch (channelId)
{
case Constants.ChatChannelGuild:
//Guild* guild = player.getGuild(); //TODO: GUILD
//if (!guild) {
// return false;
//}
//auto it = guildChannels.find(guild->getId());
//if (it == guildChannels.end()) {
// return false;
//}
//delete it->second;
//guildChannels.erase(it);
break;
case Constants.ChatChannelParty:
//Party* party = player.getParty(); //TODO: PARTY
//if (!party) {
// return false;
//}
//auto it = partyChannels.find(party);
//if (it == partyChannels.end()) {
// return false;
//}
//delete it->second;
//partyChannels.erase(it);
break;
default:
PrivateChatChannel channel;
if (!PrivateChannels.TryGetValue(channelId, out channel))
{
return(false);
}
channel.CloseChannel();
return(PrivateChannels.Remove(channelId));
}
return(true);
}
private static async Task OnSocketMessage(string json)
{
try
{
Logger.Log("Received Message: " + json);
PayloadModel payload = JsonConvert.DeserializeObject <PayloadModel>(json, JsonSettings);
if (payload.Sequence.HasValue)
{
sequence = payload.Sequence.Value;
}
switch (payload.Op)
{
case 0: // Event Dispatch
break;
case 1: // Heartbeat
await Send(JsonConvert.SerializeObject(new PayloadModel <int>
{
Op = 1,
Data = sequence
}, JsonSettings));
Logger.Log("Heartbeat");
break;
case 7: // Reconnect
Logger.Log("Reconnect Requested");
await Resume();
break;
case 9: // Invalid Session
Logger.LogError("Received invalid session from discord.");
var resume = payload.As <bool>().Data;
if (resume)
{
await Resume();
}
else
{
Stop();
}
break;
case 10: // Hello
acked = true;
var heartbeat = payload.As <HeartbeatModel>().Data;
Heartbeat(heartbeat.HeartbeatInterval);
break;
case 11: // Heartbeat Ack
Logger.Log("Heatbeat Ack");
acked = true;
break;
}
if (!string.IsNullOrEmpty(payload.Event))
{
switch (payload.Event.ToLower())
{
// ------ API ------
case "ready":
{
Logger.Log("Ready.");
var ready = payload.As <ReadyModel>().Data;
Sync(() =>
{
Version = ready.Version;
session = ready.SessionId;
User = new DiscordUser(ready.User);
foreach (var channel in ready.PrivateChannels)
{
PrivateChannels[channel.Id] = new DiscordChannel(channel);
}
foreach (var guild in ready.Guilds)
{
Servers[guild.Id] = new DiscordServer(guild);
}
startTask.SetResult(true);
interfaces.OnDiscordAPIOpen();
});
}
break;
case "resumed":
{
Logger.Log("Resumed.");
Sync(() => interfaces.OnDiscordAPIResumed());
}
break;
case "reonnect":
{
Logger.Log("Reconnect.");
await Resume();
}
break;
// ------ Channels ------
case "channel_create":
{
var channel = payload.As <ChannelModel>().Data;
Sync(() =>
{
if (!string.IsNullOrEmpty(channel.GuildId))
{
Servers[channel.GuildId].Channels[channel.Id] = new DiscordChannel(channel);
interfaces.OnChannelCreated(Servers[channel.GuildId].Channels[channel.Id]);
}
else
{
PrivateChannels[channel.Id] = new DiscordChannel(channel);
interfaces.OnChannelCreated(Servers[channel.GuildId].Channels[channel.Id]);
}
});
}
break;
case "channel_update":
{
var channel = payload.As <ChannelModel>().Data;
Sync(() =>
{
if (!string.IsNullOrEmpty(channel.GuildId))
{
Servers[channel.GuildId].Channels[channel.Id] = new DiscordChannel(channel);
interfaces.OnChannelUpdated(Servers[channel.GuildId].Channels[channel.Id]);
}
else
{
PrivateChannels[channel.Id] = new DiscordChannel(channel);
interfaces.OnChannelUpdated(Servers[channel.GuildId].Channels[channel.Id]);
}
});
}
break;
case "channel_delete":
{
var channel = payload.As <ChannelModel>().Data;
Sync(() =>
{
if (!string.IsNullOrEmpty(channel.GuildId))
{
interfaces.OnChannelDeleted(Servers[channel.GuildId].Channels[channel.Id]);
Servers[channel.GuildId].Channels.Remove(channel.Id);
}
else
{
interfaces.OnChannelDeleted(Servers[channel.GuildId].Channels[channel.Id]);
PrivateChannels.Remove(channel.Id);
}
});
}
break;
case "channel_pins_update":
{
var channelPin = payload.As <ChannelPinsModel>().Data;
Sync(() =>
{
if (!string.IsNullOrEmpty(channelPin.GuildId))
{
Servers[channelPin.GuildId].Channels[channelPin.ChannelId].LastPinTimestamp = channelPin.LastPinTimestamp;
interfaces.OnChannelPinsUpdated(Servers[channelPin.GuildId].Channels[channelPin.ChannelId], channelPin.LastPinTimestamp);
}
else
{
PrivateChannels[channelPin.ChannelId].LastPinTimestamp = channelPin.LastPinTimestamp;
interfaces.OnChannelPinsUpdated(Servers[channelPin.GuildId].Channels[channelPin.ChannelId], channelPin.LastPinTimestamp);
}
});
}
break;
// ------ Servers ------
case "guild_create":
{
var guild = payload.As <GuildModel>().Data;
Sync(() =>
{
Servers[guild.Id] = new DiscordServer(guild);
interfaces.OnServerJoined(Servers[guild.Id]);
});
}
break;
case "guild_update":
{
var guild = payload.As <GuildModel>().Data;
Sync(() =>
{
Servers[guild.Id] = new DiscordServer(guild);
interfaces.OnServerUpdated(Servers[guild.Id]);
});
}
break;
case "guild_delete":
{
var guild = payload.As <GuildModel>().Data;
Sync(() =>
{
interfaces.OnServerLeft(Servers[guild.Id]);
Servers.Remove(guild.Id);
});
}
break;
case "guild_ban_add":
{
var guildBan = payload.As <GuildBanModel>().Data;
Sync(() =>
{
Servers[guildBan.GuildId].Bans[guildBan.User.Id] = new DiscordUser(guildBan.User);
interfaces.OnServerBan(Servers[guildBan.GuildId], Servers[guildBan.GuildId].Bans[guildBan.User.Id]);
});
}
break;
case "guild_ban_remove":
{
var guildBan = payload.As <GuildBanModel>().Data;
Sync(() =>
{
interfaces.OnServerUnban(Servers[guildBan.GuildId], Servers[guildBan.GuildId].Bans[guildBan.User.Id]);
Servers[guildBan.GuildId].Bans.Remove(guildBan.User.Id);
});
}
break;
case "guild_emojis_update":
{
var guildEmojis = payload.As <GuildEmojisModel>().Data;
Servers[guildEmojis.GuildId].Emojis = guildEmojis.Emojis.ToDictionary(x => x.Id, x => new DiscordEmoji(x));
}
break;
case "guild_member_add":
{
var guildMember = payload.As <GuildMemberModel>().Data;
Servers[guildMember.GuildId].Members[guildMember.User.Id] = new DiscordServerMember(guildMember);
}
break;
case "guild_member_remove":
{
var guildMember = payload.As <GuildMemberModel>().Data;
Servers[guildMember.GuildId].Members.Remove(guildMember.User.Id);
}
break;
case "guild_member_update":
{
var guildMember = payload.As <GuildMemberModel>().Data;
Servers[guildMember.GuildId].Members[guildMember.User.Id] = new DiscordServerMember(guildMember);
}
break;
case "guild_members_chunk":
{
var guildMembersChunk = payload.As <GuildMembersChunkModel>().Data;
}
break;
case "guild_role_create":
{
var guildRole = payload.As <GuildRoleModel>().Data;
Servers[guildRole.GuildId].Roles[guildRole.Role.Id] = new DiscordRole(guildRole.Role);
}
break;
case "guild_role_update":
{
var guildRole = payload.As <GuildRoleModel>().Data;
Servers[guildRole.GuildId].Roles[guildRole.Role.Id] = new DiscordRole(guildRole.Role);
}
break;
case "guild_role_delete":
{
var guildRoleId = payload.As <GuildRoleIdModel>().Data;
Servers[guildRoleId.GuildId].Roles.Remove(guildRoleId.RoleId);
}
break;
// ------ Invites ------
case "invite_create":
{
var invite = payload.As <InviteModel>().Data;
Servers[invite.GuildId].Invites[invite.Code] = new DiscordInvite(invite);
}
break;
case "invite_delete":
{
var invite = payload.As <InviteModel>().Data;
Servers[invite.GuildId].Invites.Remove(invite.Code);
}
break;
// ------ Messages ------
case "message_create":
{
var message = payload.As <MessageModel>().Data;
Sync(() =>
{
interfaces.OnMessageCreated(new DiscordMessage(message));
});
}
break;
case "message_update":
{
var message = payload.As <MessageModel>().Data;
Sync(() =>
{
interfaces.OnMessageUpdated(new DiscordMessage(message));
});
}
break;
case "message_delete":
{
var message = payload.As <MessageModel>().Data;
Sync(() =>
{
interfaces.OnMessageDeleted(new DiscordMessage(message));
});
}
break;
case "message_delete_bulk":
{
var messageBulk = payload.As <MessageBulkModel>().Data;
}
break;
case "message_reaction_add":
{
var messageReaction = payload.As <MessageReactionModel>().Data;
}
break;
case "message_reaction_remove":
{
var messageReaction = payload.As <MessageReactionModel>().Data;
}
break;
case "message_reaction_remove_all":
{
var messageReaction = payload.As <MessageReactionModel>().Data;
}
break;
case "message_reaction_remove_emoji":
{
var messageReaction = payload.As <MessageReactionModel>().Data;
}
break;
// ------ Status ------
case "presence_update":
{
var presence = payload.As <PresenceModel>().Data;
}
break;
case "typing_start":
{
var typing = payload.As <TypingModel>().Data;
}
break;
case "user_update":
{
var user = payload.As <UserModel>().Data;
}
break;
// ------ Voice ------
case "voice_state_update":
{
var voiceState = payload.As <VoiceStateModel>().Data;
}
break;
case "voice_server_update":
{
var voiceServer = payload.As <VoiceServerModel>().Data;
}
break;
// ------ Webhooks ------
case "webhooks_update":
{
var webhook = payload.As <ServerWebhookModel>().Data;
}
break;
}
}
}
catch (Exception exception)
{
Logger.LogError("Exception occured while processing message.", exception);
}
}
