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

Revert "Deserialize from String" (Ugh) 

This reverts commit 79eb3e3b30.

If course I can't just do that, ugh
Keeping the formatting would require using RawValue, but as we use one struct for sending an recieving, having to make RawValue to send would be pretty dumb
This commit is contained in:
kozabrada123 2023-05-17 17:24:29 +02:00
parent 79eb3e3b30
commit ae06991be6
2 changed files with 58 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/api/types.rs
View File

@ -994,7 +994,6 @@ pub struct GatewayIdentifyPayload {
}
impl GatewayIdentifyPayload {
/// Creates an identify payload with the same default intents as the official client
pub fn default_w_client_capabilities() -> Self {
let mut def = Self::default();
def.capabilities = 8189; // Default capabilities for a client
@ -1670,14 +1669,7 @@ impl WebSocketEvent for MessageACK {}
#[derive(Debug, Default, Deserialize, Serialize, Clone)]
pub struct GatewayPayload {
pub op: u8,
/// 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 d: Option<serde_json::Value>,
pub s: Option<u64>,
pub t: Option<String>,
}

114
src/gateway.rs
View File

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