kozabrada123/chorus
kozabrada123
/
chorus
mirror of https://github.com/polyphony-chat/chorus.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Deserialize from String instead of Value

This commit is contained in:
kozabrada123 2023-05-17 17:03:03 +02:00
parent 57dd0978dd
commit 79eb3e3b30
2 changed files with 66 additions and 58 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/api/types.rs
View File

@ -994,6 +994,7 @@ pub struct GatewayIdentifyPayload {
} }
impl GatewayIdentifyPayload { impl GatewayIdentifyPayload {
/// Creates an identify payload with the same default intents as the official client
pub fn default_w_client_capabilities() -> Self { pub fn default_w_client_capabilities() -> Self {
let mut def = Self::default(); let mut def = Self::default();
def.capabilities = 8189; // Default capabilities for a client def.capabilities = 8189; // Default capabilities for a client
@ -1669,7 +1670,14 @@ impl WebSocketEvent for MessageACK {}
#[derive(Debug, Default, Deserialize, Serialize, Clone)] #[derive(Debug, Default, Deserialize, Serialize, Clone)]
pub struct GatewayPayload { pub struct GatewayPayload {
pub op: u8, pub op: u8,
pub d: Option<serde_json::Value>, /// In reality this is a [serde_json::Value], but deserializing into a value and then into types causes problems in practice??
/// So, we use this directly as a json string and then deserialize using [serde_json::from_str]
///
/// (Particualarly, deserializing to value causes later problems with custom serializers like [deserialize_option_number_from_string] (in my experience))
///
/// Also, deserializing [WebSocketEvent]s from a string gives us the column where we get a serde error
/// (i.e. line: 1, column: 13 vs line: 0, column: 0)
pub d: Option<String>,
pub s: Option<u64>, pub s: Option<u64>,
pub t: Option<String>, pub t: Option<String>,
} }

114
src/gateway.rs
View File

@ -33,7 +33,7 @@ pub struct GatewayHandle {
impl GatewayHandle { impl GatewayHandle {
/// Sends json to the gateway with an opcode /// Sends json to the gateway with an opcode
async fn send_json_event(&self, op: u8, to_send: serde_json::Value) { async fn send_json_event(&self, op: u8, to_send: String) {
let gateway_payload = GatewayPayload { op, d: Some(to_send), s: None, t: None }; let gateway_payload = GatewayPayload { op, d: Some(to_send), s: None, t: None };
@ -47,7 +47,7 @@ impl GatewayHandle {
/// Sends an identify event to the gateway /// Sends an identify event to the gateway
pub async fn send_identify(&self, to_send: GatewayIdentifyPayload) { pub async fn send_identify(&self, to_send: GatewayIdentifyPayload) {
let to_send_value = serde_json::to_value(&to_send).unwrap(); let to_send_value = serde_json::to_string(&to_send).unwrap();
println!("GW: Sending Identify.."); println!("GW: Sending Identify..");
@ -57,7 +57,7 @@ impl GatewayHandle {
/// Sends a resume event to the gateway /// Sends a resume event to the gateway
pub async fn send_resume(&self, to_send: GatewayResume) { pub async fn send_resume(&self, to_send: GatewayResume) {
let to_send_value = serde_json::to_value(&to_send).unwrap(); let to_send_value = serde_json::to_string(&to_send).unwrap();
println!("GW: Sending Resume.."); println!("GW: Sending Resume..");
@ -67,7 +67,7 @@ impl GatewayHandle {
/// Sends an update presence event to the gateway /// Sends an update presence event to the gateway
pub async fn send_update_presence(&self, to_send: PresenceUpdate) { pub async fn send_update_presence(&self, to_send: PresenceUpdate) {
let to_send_value = serde_json::to_value(&to_send).unwrap(); let to_send_value = serde_json::to_string(&to_send).unwrap();
println!("GW: Sending Presence Update.."); println!("GW: Sending Presence Update..");
@ -77,7 +77,7 @@ impl GatewayHandle {
/// Sends a Request Guild Members to the server /// Sends a Request Guild Members to the server
pub async fn send_request_guild_members(&self, to_send: GatewayRequestGuildMembers) { pub async fn send_request_guild_members(&self, to_send: GatewayRequestGuildMembers) {
let to_send_value = serde_json::to_value(&to_send).unwrap(); let to_send_value = serde_json::to_string(&to_send).unwrap();
println!("GW: Sending Request Guild Members.."); println!("GW: Sending Request Guild Members..");
@ -87,7 +87,7 @@ impl GatewayHandle {
/// Sends a Request Guild Members to the server /// Sends a Request Guild Members to the server
pub async fn send_update_voice_state(&self, to_send: GatewayVoiceStateUpdate) { pub async fn send_update_voice_state(&self, to_send: GatewayVoiceStateUpdate) {
let to_send_value = serde_json::to_value(&to_send).unwrap(); let to_send_value = serde_json::to_string(&to_send).unwrap();
println!("GW: Sending Voice State Update.."); println!("GW: Sending Voice State Update..");
@ -97,7 +97,7 @@ impl GatewayHandle {
/// Sends a Call Sync /// Sends a Call Sync
pub async fn send_call_sync(&self, to_send: CallSync) { pub async fn send_call_sync(&self, to_send: CallSync) {
let to_send_value = serde_json::to_value(&to_send).unwrap(); let to_send_value = serde_json::to_string(&to_send).unwrap();
println!("GW: Sending Call Sync.."); println!("GW: Sending Call Sync..");
@ -107,7 +107,7 @@ impl GatewayHandle {
/// Sends a Lazy Request /// Sends a Lazy Request
pub async fn send_lazy_request(&self, to_send: LazyRequest) { pub async fn send_lazy_request(&self, to_send: LazyRequest) {
let to_send_value = serde_json::to_value(&to_send).unwrap(); let to_send_value = serde_json::to_string(&to_send).unwrap();
println!("GW: Sending Lazy Request.."); println!("GW: Sending Lazy Request..");
@ -159,7 +159,7 @@ impl Gateway {
println!("GW: Received Hello"); println!("GW: Received Hello");
let gateway_hello: HelloData = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let gateway_hello: HelloData = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
gateway.heartbeat_handler = Some(HeartbeatHandler::new(gateway_hello.heartbeat_interval, shared_tx.clone())); gateway.heartbeat_handler = Some(HeartbeatHandler::new(gateway_hello.heartbeat_interval, shared_tx.clone()));
// Now we can continously check for messages in a different task, since we aren't going to receive another hello // Now we can continously check for messages in a different task, since we aren't going to receive another hello
@ -205,11 +205,11 @@ impl Gateway {
// "Some" of these are uncodumented // "Some" of these are uncodumented
match gateway_payload_t.as_str() { match gateway_payload_t.as_str() {
"READY" => { "READY" => {
let new_data: GatewayReady = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GatewayReady = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.session.ready.update_data(new_data).await; self.events.lock().await.session.ready.update_data(new_data).await;
}, },
"READY_SUPPLEMENTAL" => { "READY_SUPPLEMENTAL" => {
let new_data: GatewayReadySupplemental = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GatewayReadySupplemental = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.session.ready_supplimental.update_data(new_data).await; self.events.lock().await.session.ready_supplimental.update_data(new_data).await;
} }
"RESUMED" => {} "RESUMED" => {}
@ -219,120 +219,120 @@ impl Gateway {
"AUTO_MODERATION_RULE_DELETE" => {} "AUTO_MODERATION_RULE_DELETE" => {}
"AUTO_MODERATION_ACTION_EXECUTION" => {} "AUTO_MODERATION_ACTION_EXECUTION" => {}
"CHANNEL_CREATE" => { "CHANNEL_CREATE" => {
let new_data: ChannelCreate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ChannelCreate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.channel.create.update_data(new_data).await; self.events.lock().await.channel.create.update_data(new_data).await;
} }
"CHANNEL_UPDATE" => { "CHANNEL_UPDATE" => {
let new_data: ChannelUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ChannelUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.channel.update.update_data(new_data).await; self.events.lock().await.channel.update.update_data(new_data).await;
} }
"CHANNEL_UNREAD_UPDATE" => { "CHANNEL_UNREAD_UPDATE" => {
let new_data: ChannelUnreadUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ChannelUnreadUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.channel.unread_update.update_data(new_data).await; self.events.lock().await.channel.unread_update.update_data(new_data).await;
} }
"CHANNEL_DELETE" => { "CHANNEL_DELETE" => {
let new_data: ChannelDelete = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ChannelDelete = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.channel.delete.update_data(new_data).await; self.events.lock().await.channel.delete.update_data(new_data).await;
} }
"CHANNEL_PINS_UPDATE" => { "CHANNEL_PINS_UPDATE" => {
let new_data: ChannelPinsUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ChannelPinsUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.channel.pins_update.update_data(new_data).await; self.events.lock().await.channel.pins_update.update_data(new_data).await;
} }
"CALL_CREATE" => { "CALL_CREATE" => {
let new_data: CallCreate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: CallCreate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.call.create.update_data(new_data).await; self.events.lock().await.call.create.update_data(new_data).await;
}, },
"CALL_UPDATE" => { "CALL_UPDATE" => {
let new_data: CallUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: CallUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.call.update.update_data(new_data).await; self.events.lock().await.call.update.update_data(new_data).await;
} }
"CALL_DELETE" => { "CALL_DELETE" => {
let new_data: CallDelete = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: CallDelete = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.call.delete.update_data(new_data).await; self.events.lock().await.call.delete.update_data(new_data).await;
} }
"THREAD_CREATE" => { "THREAD_CREATE" => {
let new_data: ThreadCreate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ThreadCreate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.thread.create.update_data(new_data).await; self.events.lock().await.thread.create.update_data(new_data).await;
} }
"THREAD_UPDATE" => { "THREAD_UPDATE" => {
let new_data: ThreadUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ThreadUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.thread.update.update_data(new_data).await; self.events.lock().await.thread.update.update_data(new_data).await;
} }
"THREAD_DELETE" => { "THREAD_DELETE" => {
let new_data: ThreadDelete = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ThreadDelete = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.thread.delete.update_data(new_data).await; self.events.lock().await.thread.delete.update_data(new_data).await;
} }
"THREAD_LIST_SYNC" => { "THREAD_LIST_SYNC" => {
let new_data: ThreadListSync = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ThreadListSync = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.thread.list_sync.update_data(new_data).await; self.events.lock().await.thread.list_sync.update_data(new_data).await;
} }
"THREAD_MEMBER_UPDATE" => { "THREAD_MEMBER_UPDATE" => {
let new_data: ThreadMemberUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ThreadMemberUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.thread.member_update.update_data(new_data).await; self.events.lock().await.thread.member_update.update_data(new_data).await;
} }
"THREAD_MEMBERS_UPDATE" => { "THREAD_MEMBERS_UPDATE" => {
let new_data: ThreadMembersUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: ThreadMembersUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.thread.members_update.update_data(new_data).await; self.events.lock().await.thread.members_update.update_data(new_data).await;
} }
"GUILD_CREATE" => { "GUILD_CREATE" => {
let new_data: GuildCreate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildCreate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.create.update_data(new_data).await; self.events.lock().await.guild.create.update_data(new_data).await;
} }
"GUILD_UPDATE" => { "GUILD_UPDATE" => {
let new_data: GuildUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.update.update_data(new_data).await; self.events.lock().await.guild.update.update_data(new_data).await;
} }
"GUILD_DELETE" => { "GUILD_DELETE" => {
let new_data: GuildDelete = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildDelete = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.delete.update_data(new_data).await; self.events.lock().await.guild.delete.update_data(new_data).await;
} }
"GUILD_AUDIT_LOG_ENTRY_CREATE" => {} "GUILD_AUDIT_LOG_ENTRY_CREATE" => {}
"GUILD_BAN_ADD" => { "GUILD_BAN_ADD" => {
let new_data: GuildBanAdd = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildBanAdd = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.ban_add.update_data(new_data).await; self.events.lock().await.guild.ban_add.update_data(new_data).await;
} }
"GUILD_BAN_REMOVE" => { "GUILD_BAN_REMOVE" => {
let new_data: GuildBanRemove = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildBanRemove = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.ban_remove.update_data(new_data).await; self.events.lock().await.guild.ban_remove.update_data(new_data).await;
} }
"GUILD_EMOJIS_UPDATE" => { "GUILD_EMOJIS_UPDATE" => {
let new_data: GuildEmojisUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildEmojisUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.emojis_update.update_data(new_data).await; self.events.lock().await.guild.emojis_update.update_data(new_data).await;
} }
"GUILD_STICKERS_UPDATE" => { "GUILD_STICKERS_UPDATE" => {
let new_data: GuildStickersUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildStickersUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.stickers_update.update_data(new_data).await; self.events.lock().await.guild.stickers_update.update_data(new_data).await;
} }
"GUILD_INTEGRATIONS_UPDATE" => { "GUILD_INTEGRATIONS_UPDATE" => {
let new_data: GuildIntegrationsUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildIntegrationsUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.integrations_update.update_data(new_data).await; self.events.lock().await.guild.integrations_update.update_data(new_data).await;
} }
"GUILD_MEMBER_ADD" => { "GUILD_MEMBER_ADD" => {
let new_data: GuildMemberAdd = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildMemberAdd = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.member_add.update_data(new_data).await; self.events.lock().await.guild.member_add.update_data(new_data).await;
} }
"GUILD_MEMBER_REMOVE" => { "GUILD_MEMBER_REMOVE" => {
let new_data: GuildMemberRemove = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildMemberRemove = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.member_remove.update_data(new_data).await; self.events.lock().await.guild.member_remove.update_data(new_data).await;
} }
"GUILD_MEMBER_UPDATE" => { "GUILD_MEMBER_UPDATE" => {
let new_data: GuildMemberUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildMemberUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.member_update.update_data(new_data).await; self.events.lock().await.guild.member_update.update_data(new_data).await;
} }
"GUILD_MEMBERS_CHUNK" => { "GUILD_MEMBERS_CHUNK" => {
let new_data: GuildMembersChunk = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildMembersChunk = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.members_chunk.update_data(new_data).await; self.events.lock().await.guild.members_chunk.update_data(new_data).await;
} }
"GUILD_ROLE_CREATE" => { "GUILD_ROLE_CREATE" => {
let new_data: GuildRoleCreate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildRoleCreate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.role_create.update_data(new_data).await; self.events.lock().await.guild.role_create.update_data(new_data).await;
} }
"GUILD_ROLE_UPDATE" => { "GUILD_ROLE_UPDATE" => {
let new_data: GuildRoleUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildRoleUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.role_update.update_data(new_data).await; self.events.lock().await.guild.role_update.update_data(new_data).await;
} }
"GUILD_ROLE_DELETE" => { "GUILD_ROLE_DELETE" => {
let new_data: GuildRoleDelete = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: GuildRoleDelete = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.guild.role_delete.update_data(new_data).await; self.events.lock().await.guild.role_delete.update_data(new_data).await;
} }
"GUILD_SCHEDULED_EVENT_CREATE" => {} "GUILD_SCHEDULED_EVENT_CREATE" => {}
@ -341,58 +341,58 @@ impl Gateway {
"GUILD_SCHEDULED_EVENT_USER_ADD" => {} "GUILD_SCHEDULED_EVENT_USER_ADD" => {}
"GUILD_SCHEDULED_EVENT_USER_REMOVE" => {} "GUILD_SCHEDULED_EVENT_USER_REMOVE" => {}
"INTEGRATION_CREATE" => { "INTEGRATION_CREATE" => {
let new_data: IntegrationCreate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: IntegrationCreate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.integration.create.update_data(new_data).await; self.events.lock().await.integration.create.update_data(new_data).await;
} }
"INTEGRATION_UPDATE" => { "INTEGRATION_UPDATE" => {
let new_data: IntegrationUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: IntegrationUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.integration.update.update_data(new_data).await; self.events.lock().await.integration.update.update_data(new_data).await;
} }
"INTEGRATION_DELETE" => { "INTEGRATION_DELETE" => {
let new_data: IntegrationDelete = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: IntegrationDelete = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.integration.delete.update_data(new_data).await; self.events.lock().await.integration.delete.update_data(new_data).await;
} }
"INTERACTION_CREATE" => {} "INTERACTION_CREATE" => {}
"INVITE_CREATE" => {} "INVITE_CREATE" => {}
"INVITE_DELETE" => {} "INVITE_DELETE" => {}
"MESSAGE_CREATE" => { "MESSAGE_CREATE" => {
let new_data: MessageCreate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageCreate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.create.update_data(new_data).await; self.events.lock().await.message.create.update_data(new_data).await;
} }
"MESSAGE_UPDATE" => { "MESSAGE_UPDATE" => {
let new_data: MessageUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.update.update_data(new_data).await; self.events.lock().await.message.update.update_data(new_data).await;
} }
"MESSAGE_DELETE" => { "MESSAGE_DELETE" => {
let new_data: MessageDelete = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageDelete = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.delete.update_data(new_data).await; self.events.lock().await.message.delete.update_data(new_data).await;
} }
"MESSAGE_DELETE_BULK" => { "MESSAGE_DELETE_BULK" => {
let new_data: MessageDeleteBulk = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageDeleteBulk = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.delete_bulk.update_data(new_data).await; self.events.lock().await.message.delete_bulk.update_data(new_data).await;
} }
"MESSAGE_REACTION_ADD" => { "MESSAGE_REACTION_ADD" => {
let new_data: MessageReactionAdd = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageReactionAdd = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.reaction_add.update_data(new_data).await; self.events.lock().await.message.reaction_add.update_data(new_data).await;
} }
"MESSAGE_REACTION_REMOVE" => { "MESSAGE_REACTION_REMOVE" => {
let new_data: MessageReactionRemove = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageReactionRemove = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.reaction_remove.update_data(new_data).await; self.events.lock().await.message.reaction_remove.update_data(new_data).await;
} }
"MESSAGE_REACTION_REMOVE_ALL" => { "MESSAGE_REACTION_REMOVE_ALL" => {
let new_data: MessageReactionRemoveAll = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageReactionRemoveAll = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.reaction_remove_all.update_data(new_data).await; self.events.lock().await.message.reaction_remove_all.update_data(new_data).await;
} }
"MESSAGE_REACTION_REMOVE_EMOJI" => { "MESSAGE_REACTION_REMOVE_EMOJI" => {
let new_data: MessageReactionRemoveEmoji= serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageReactionRemoveEmoji= serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.reaction_remove_emoji.update_data(new_data).await; self.events.lock().await.message.reaction_remove_emoji.update_data(new_data).await;
}, },
"MESSAGE_ACK" => { "MESSAGE_ACK" => {
let new_data: MessageACK = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: MessageACK = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.message.ack.update_data(new_data).await; self.events.lock().await.message.ack.update_data(new_data).await;
} }
"PRESENCE_UPDATE" => { "PRESENCE_UPDATE" => {
let new_data: PresenceUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: PresenceUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.user.presence_update.update_data(new_data).await; self.events.lock().await.user.presence_update.update_data(new_data).await;
} }
// What is this? // What is this?
@ -401,22 +401,22 @@ impl Gateway {
"STAGE_INSTANCE_UPDATE" => {} "STAGE_INSTANCE_UPDATE" => {}
"STAGE_INSTANCE_DELETE" => {} "STAGE_INSTANCE_DELETE" => {}
"SESSIONS_REPLACE" => { "SESSIONS_REPLACE" => {
let sessions: Vec<Session> = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let sessions: Vec<Session> = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
let new_data = SessionsReplace {sessions}; let new_data = SessionsReplace {sessions};
self.events.lock().await.session.replace.update_data(new_data).await; self.events.lock().await.session.replace.update_data(new_data).await;
} }
"TYPING_START" => { "TYPING_START" => {
let new_data: TypingStartEvent = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: TypingStartEvent = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.user.typing_start_event.update_data(new_data).await; self.events.lock().await.user.typing_start_event.update_data(new_data).await;
} }
"USER_UPDATE" => { "USER_UPDATE" => {
let new_data: UserUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: UserUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.user.update.update_data(new_data).await; self.events.lock().await.user.update.update_data(new_data).await;
} }
"VOICE_STATE_UPDATE" => {} "VOICE_STATE_UPDATE" => {}
"VOICE_SERVER_UPDATE" => {} "VOICE_SERVER_UPDATE" => {}
"WEBHOOKS_UPDATE" => { "WEBHOOKS_UPDATE" => {
let new_data: WebhooksUpdate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); let new_data: WebhooksUpdate = serde_json::from_str(&gateway_payload.d.unwrap()).unwrap();
self.events.lock().await.webhooks.update.update_data(new_data).await; self.events.lock().await.webhooks.update.update_data(new_data).await;
} }
_ => { _ => {