private void HandleEvent(DiscordGatewayPayload payload)
{
//TODO: This doesn't need a try catch, as it should Invoke(), it should not throw
try
{
messageCallback.Invoke(payload);
//string messageType = payload.EventType;
//switch (messageType)
//{
// case "MESSAGE_CREATE":
// messageCallback.Invoke(payload.EventData);
// break;
// case "GUILD_CREATE":
// guildCreateCallback.Invoke(payload.EventData);
// break;
// default:
// break;
//}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
//string sender = payload["s"]
//messageCallback.Invoke()
}
private void Heartbeat(object sender, ElapsedEventArgs e)
{
Console.WriteLine("Sent Heartbeat!");
var heartBeatPayload = new DiscordGatewayPayload <dynamic>
{
Op = 1,
D = Sequence
};
Send(heartBeatPayload);
}
/// <summary>
/// Any payload received from Gateway.
/// The type of payload is defined by the Opcode
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void OnMessage(object sender, MessageReceivedEventArgs e)
{
try
{
//JObject payload = JObject.Parse(e.Message);
DiscordGatewayPayload gatewayPayload = JsonConvert.DeserializeObject <DiscordGatewayPayload>(e.Message);
// Update the last sequence received, used when sending heartbeats
lastHeartbeatSequence = gatewayPayload.Sequence;
// Opcodes 2, 3, 4, 6, and 8 are Send only, so they don't need to be handled here
switch ((OpCode)gatewayPayload.Opcode)
{
case OpCode.Dispatch:
HandleEvent(gatewayPayload);
break;
case OpCode.Heartbeat:
break;
case OpCode.Reconnect:
break;
case OpCode.InvalidSession:
break;
case OpCode.Hello:
OnHelloReceived(gatewayPayload);
break;
case OpCode.HeartbeatAck:
heartbeatAcknowledged = true;
break;
default:
break;
}
//DELETE: This is only for testing
if (gatewayPayload?.EventData != null)
{
Logger.LogInfo(gatewayPayload.EventData.ToString());
}
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
void OnMessageCreate(DiscordGatewayPayload payload)
{
try
{
Message message = payload.EventData.ToObject <Message>();
FullMessage fullMessage = new FullMessage(this, message);
CommandHandler?.HandleMessage(fullMessage);
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
void HandleGatewayEvent(DiscordGatewayPayload payload)
{
switch (payload.EventType)
{
case "MESSAGE_CREATE":
OnMessageCreate(payload);
break;
case "GUILD_CREATE":
CreateGuild(payload.EventData);
break;
default:
break;
}
}
private void OnHelloReceived(DiscordGatewayPayload helloPayload)
{
try
{
//TODO: Define a Hello event structure instead of using JSON LINQ
int interval = helloPayload.EventData["heartbeat_interval"].ToObject <int>();
if (interval == 0)
{
// TEMP - in case interval was not set, use a default
interval = 10000;
}
StartHeartbeat(interval);
}
catch (Exception ex)
{
Logger.LogException(ex);
}
}
private async Task _onWsMessage(object sender, MessageEventArgs msg)
{
var serializedPayload = msg.Data;
var deserializedPayload = JsonConvert.DeserializeObject <DiscordGatewayPayload <dynamic> >(serializedPayload,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
if (deserializedPayload.S != 0)
{
Sequence = deserializedPayload.S;
}
switch (deserializedPayload.Op)
{
case 0:
{
switch (deserializedPayload.T)
{
case "READY":
{
var readyPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <ReadyPayload> >(
JsonConvert.SerializeObject(deserializedPayload));
Client.ClientUser = new ClientUser
{
Avatar = readyPayload.D.User.Avatar,
Bot = readyPayload.D.User.Bot,
Discriminator = readyPayload.D.User.Discriminator,
Flags = readyPayload.D.User.Flags,
Id = readyPayload.D.User.Id,
Username = readyPayload.D.User.Username
};
SessionId = readyPayload.D.SessionId;
HeartbeatTimer.Start();
HeartbeatTimer.Elapsed += Heartbeat;
InitialGuilds = readyPayload.D.UnavailableGuilds.Length;
break;
}
case "GUILD_CREATE":
{
var guildPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <GuildCreatePayload> >(
JsonConvert.SerializeObject(deserializedPayload));
if (guildPayload.D.Lazy)
{
InitialGuilds--;
await Client.Guilds.GetOrCreateAsync(guildPayload.D.Id,
async() => JsonConvert
.DeserializeObject <DiscordGatewayPayload <Guild> >(JsonConvert.SerializeObject(guildPayload)).D);
if (InitialGuilds == 0)
{
Client.ReadyEvent(EventArgs.Empty);
}
}
else
{
var seeIfGuildWasUnavailable = await Client.UnavailableGuilds.GetAsync(guildPayload.D.Id);
if (seeIfGuildWasUnavailable == null)
{
var guild = await Client.Guilds.GetOrCreateAsync(guildPayload.D.Id,
async() => JsonConvert
.DeserializeObject <DiscordGatewayPayload <Guild> >(JsonConvert.SerializeObject(guildPayload)).D);
Client.GuildCreateEvent(guild);
}
else
{
var guild = await Client.Guilds.GetOrCreateAsync(guildPayload.D.Id,
async() => JsonConvert
.DeserializeObject <DiscordGatewayPayload <Guild> >(JsonConvert.SerializeObject(guildPayload)).D);
await Client.UnavailableGuilds.DeleteAsync(guildPayload.D.Id);
Client.GuildAvailableEvent(guild);
}
}
break;
}
case "GUILD_UPDATE":
{
var guildPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <GuildUpdatePayload> >(
JsonConvert.SerializeObject(deserializedPayload));
var findGuild = await Client.Guilds.GetAsync(guildPayload.D.Id);
if (findGuild == null)
{
// TODO: Create the route struct so that i can get the guild and add it to cache.
}
else
{
var newGuild = await Client.Guilds.UpdateAsync(guildPayload.D.Id,
JsonConvert.DeserializeObject <DiscordGatewayPayload <Guild> >(
JsonConvert.SerializeObject(deserializedPayload)).D);
Client.GuildUpdateEvent(new GuildUpdateEventArgs
{
NewGuild = newGuild,
OldGuild = findGuild
});
}
break;
}
case "GUILD_DELETE":
{
var guildPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <GuildDeletePayload> >(
JsonConvert.SerializeObject(deserializedPayload));
var findGuild = await Client.Guilds.GetAsync(guildPayload.D.Id);
if (findGuild == null)
{
// TODO: Create the route struct/class so that i can get the guild and add it to cache.
}
else
{
await Client.Guilds.DeleteAsync(guildPayload.D.Id);
if (guildPayload.D.Unavailable)
{
var unavailableGuild =
await Client.UnavailableGuilds.GetOrCreateAsync(guildPayload.D.Id, async() => findGuild);
Client.GuildUnavailableEvent(unavailableGuild);
}
else
{
Client.GuildDeleteEvent(findGuild);
}
}
break;
}
}
break;
}
case 10:
{
var helloPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <HelloPayload> >(
JsonConvert.SerializeObject(deserializedPayload));
if (HeartbeatTimer != null)
{
HeartbeatTimer.Elapsed -= Heartbeat;
HeartbeatTimer.Stop();
HeartbeatTimer.Dispose();
}
HeartbeatTimer = new Timer(helloPayload.D.HeartbeatInterval);
HeartbeatTimer.AutoReset = true;
var identifyPayload = new DiscordGatewayPayload <IdentifyPayload>
{
Op = 2,
D = new IdentifyPayload
{
Token = Client.Token,
Properties = new IdentifyPropertiesPayload
{
Browser = "Disharp",
Device = "Disharp",
Os = Environment.OSVersion.Platform.ToString()
},
Compress = false,
LargeThreshold = Client.ClientOptions.LargeThreshold,
Presence = Client.ClientOptions.WsOptions.Presence,
Intents = Client.ClientOptions.WsOptions.Intents
}
};
Send(identifyPayload);
break;
}
}
Console.WriteLine(JsonConvert.SerializeObject(deserializedPayload));
}
