From f74b9c4c0da73bff04a2e0090eee9d8c96a33902 Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Thu, 25 May 2023 23:09:18 +0200 Subject: [PATCH] start porting over new types folder --- src/api/channels/channels.rs | 8 +- src/api/mod.rs | 4 - src/api/policies/instance/instance.rs | 11 +- src/api/users/users.rs | 25 +- src/gateway.rs | 439 ++++++++++++++---- src/instance.rs | 45 +- .../config/types/general_configuration.rs | 26 +- src/types/mod.rs | 1 + types/entities/user.rs | 130 +----- 9 files changed, 430 insertions(+), 259 deletions(-) diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index 51552a1..dab5eb7 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -1,11 +1,7 @@ use reqwest::Client; use serde_json::from_str; -use crate::{ - api::{limits::Limits, types}, - errors::InstanceServerError, - limit::LimitedRequester, -}; +use crate::{api::limits::Limits, errors::InstanceServerError, limit::LimitedRequester}; impl types::Channel { pub async fn get( @@ -14,7 +10,7 @@ impl types::Channel { channel_id: &str, limits_user: &mut Limits, limits_instance: &mut Limits, - ) -> Result { + ) -> Result { let request = Client::new() .get(format!("{}/channels/{}/", url_api, channel_id)) .bearer_auth(token); diff --git a/src/api/mod.rs b/src/api/mod.rs index 37abc50..0bac755 100644 --- a/src/api/mod.rs +++ b/src/api/mod.rs @@ -2,13 +2,9 @@ pub mod auth; pub mod channels; pub mod guilds; pub mod policies; -pub mod schemas; -pub mod types; pub mod users; pub use channels::messages::*; pub use guilds::*; pub use policies::instance::instance::*; pub use policies::instance::limits::*; -pub use schemas::*; -pub use types::*; diff --git a/src/api/policies/instance/instance.rs b/src/api/policies/instance/instance.rs index 2196b80..0ec8acb 100644 --- a/src/api/policies/instance/instance.rs +++ b/src/api/policies/instance/instance.rs @@ -2,7 +2,8 @@ use reqwest::Client; use serde_json::from_str; use crate::errors::InstanceServerError; -use crate::{api::types::InstancePolicies, instance::Instance}; +use crate::instance::Instance; +use crate::types::GeneralConfiguration; impl Instance { /** @@ -10,7 +11,9 @@ impl Instance { # Errors [`InstanceServerError`] - If the request fails. */ - pub async fn instance_policies_schema(&self) -> Result { + pub async fn general_configuration_schema( + &self, + ) -> Result { let client = Client::new(); let endpoint_url = self.urls.get_api().to_string() + "/policies/instance/"; let request = match client.get(&endpoint_url).send().await { @@ -30,7 +33,7 @@ impl Instance { } let body = request.text().await.unwrap(); - let instance_policies_schema: InstancePolicies = from_str(&body).unwrap(); + let instance_policies_schema: GeneralConfiguration = from_str(&body).unwrap(); Ok(instance_policies_schema) } } @@ -49,6 +52,6 @@ mod instance_policies_schema_test { let limited_requester = LimitedRequester::new().await; let test_instance = Instance::new(urls.clone()).await.unwrap(); - let _schema = test_instance.instance_policies_schema().await.unwrap(); + let _schema = test_instance.general_configuration_schema().await.unwrap(); } } diff --git a/src/api/users/users.rs b/src/api/users/users.rs index cf052aa..48f7019 100644 --- a/src/api/users/users.rs +++ b/src/api/users/users.rs @@ -2,17 +2,14 @@ use reqwest::Client; use serde_json::{from_str, to_string}; use crate::{ - api::{ - limits::Limits, - types::{User, UserObject}, - UserModifySchema, UserSettings, - }, + api::limits::Limits, errors::InstanceServerError, - instance::Instance, + instance::{Instance, UserMeta}, limit::LimitedRequester, + types::{User, UserModifySchema}, }; -impl User { +impl UserMeta { /** Get a user object by id, or get the current user. # Arguments @@ -28,7 +25,7 @@ impl User { url_api: &String, id: Option<&String>, instance_limits: &mut Limits, - ) -> Result { + ) -> Result { let url: String; if id.is_none() { url = format!("{}/users/@me/", url_api); @@ -49,7 +46,7 @@ impl User { { Ok(result) => { let result_text = result.text().await.unwrap(); - Ok(serde_json::from_str::(&result_text).unwrap()) + Ok(serde_json::from_str::(&result_text).unwrap()) } Err(e) => Err(e), } @@ -59,7 +56,7 @@ impl User { token: &String, url_api: &String, instance_limits: &mut Limits, - ) -> Result { + ) -> Result { let request: reqwest::RequestBuilder = Client::new() .get(format!("{}/users/@me/settings/", url_api)) .bearer_auth(token); @@ -91,7 +88,7 @@ impl User { pub async fn modify( &mut self, modify_schema: UserModifySchema, - ) -> Result { + ) -> Result { if modify_schema.new_password.is_some() || modify_schema.email.is_some() || modify_schema.code.is_some() @@ -118,7 +115,7 @@ impl User { Ok(response) => response, Err(e) => return Err(e), }; - let user_updated: UserObject = from_str(&result.text().await.unwrap()).unwrap(); + let user_updated: User = from_str(&result.text().await.unwrap()).unwrap(); let _ = std::mem::replace( &mut self.object.as_mut().unwrap(), &mut user_updated.clone(), @@ -171,8 +168,8 @@ impl Instance { &mut self, token: String, id: Option<&String>, - ) -> Result { - User::get( + ) -> Result { + UserMeta::get( &token, &self.urls.get_api().to_string(), id, diff --git a/src/gateway.rs b/src/gateway.rs index c79004f..15b299e 100644 --- a/src/gateway.rs +++ b/src/gateway.rs @@ -1,12 +1,46 @@ -use std::sync::Arc; -use crate::api::types::*; -use crate::api::WebSocketEvent; use crate::errors::ObserverError; use crate::gateway::events::Events; +use crate::types::Channel; +use crate::types::ChannelCreate; +use crate::types::ChannelDelete; +use crate::types::ChannelPinsUpdate; +use crate::types::ChannelUpdate; +use crate::types::GatewayHeartbeat; +use crate::types::GatewayIdentifyPayload; +use crate::types::GatewayPayload; +use crate::types::GatewayReady; +use crate::types::GatewayRequestGuildMembers; +use crate::types::GatewayResume; +use crate::types::GatewayVoiceStateUpdate; +use crate::types::GuildBanAdd; +use crate::types::GuildBanRemove; +use crate::types::GuildCreate; +use crate::types::HelloData; +use crate::types::MessageCreate; +use crate::types::MessageDelete; +use crate::types::MessageDeleteBulk; +use crate::types::MessageReactionAdd; +use crate::types::MessageReactionRemove; +use crate::types::MessageReactionRemoveAll; +use crate::types::MessageReactionRemoveEmoji; +use crate::types::MessageUpdate; +use crate::types::PresenceUpdate; +use crate::types::ThreadCreate; +use crate::types::ThreadDelete; +use crate::types::ThreadListSync; +use crate::types::ThreadMemberUpdate; +use crate::types::ThreadMembersUpdate; +use crate::types::ThreadUpdate; +use crate::types::TypingStartEvent; +use crate::types::UnavailableGuild; +use crate::types::User; +use crate::types::UserUpdate; +use crate::types::WebSocketEvent; +use futures_util::stream::SplitSink; use futures_util::SinkExt; use futures_util::StreamExt; -use futures_util::stream::SplitSink; use native_tls::TlsConnector; +use std::sync::Arc; use tokio::net::TcpStream; use tokio::sync::mpsc; use tokio::sync::mpsc::error::TryRecvError; @@ -16,7 +50,7 @@ use tokio::task; use tokio::time; use tokio::time::Instant; use tokio_tungstenite::MaybeTlsStream; -use tokio_tungstenite::{WebSocketStream, Connector, connect_async_tls_with_config}; +use tokio_tungstenite::{connect_async_tls_with_config, Connector, WebSocketStream}; #[derive(Debug)] /** @@ -28,14 +62,25 @@ Using this handle you can also send Gateway Events directly. pub struct GatewayHandle { pub url: String, pub events: Arc>, - pub websocket_tx: Arc>, tokio_tungstenite::tungstenite::Message>>>, + pub websocket_tx: Arc< + Mutex< + SplitSink< + WebSocketStream>, + tokio_tungstenite::tungstenite::Message, + >, + >, + >, } impl GatewayHandle { /// Sends json to the gateway with an opcode 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 }; + let gateway_payload = GatewayPayload { + op, + d: Some(to_send), + s: None, + t: None, + }; let payload_json = serde_json::to_string(&gateway_payload).unwrap(); @@ -46,7 +91,6 @@ 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_value(&to_send).unwrap(); println!("GW: Sending Identify.."); @@ -56,7 +100,6 @@ 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_value(&to_send).unwrap(); println!("GW: Sending Resume.."); @@ -66,7 +109,6 @@ 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_value(&to_send).unwrap(); println!("GW: Sending Presence Update.."); @@ -76,7 +118,6 @@ 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_value(&to_send).unwrap(); println!("GW: Sending Request Guild Members.."); @@ -86,7 +127,6 @@ 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_value(&to_send).unwrap(); println!("GW: Sending Voice State Update.."); @@ -98,14 +138,20 @@ impl GatewayHandle { pub struct Gateway { pub events: Arc>, heartbeat_handler: Option, - pub websocket_tx: Arc>, tokio_tungstenite::tungstenite::Message>>> + pub websocket_tx: Arc< + Mutex< + SplitSink< + WebSocketStream>, + tokio_tungstenite::tungstenite::Message, + >, + >, + >, } impl Gateway { pub async fn new( websocket_url: String, ) -> Result { - let (ws_stream, _) = match connect_async_tls_with_config( &websocket_url, None, @@ -123,7 +169,11 @@ impl Gateway { let shared_tx = Arc::new(Mutex::new(ws_tx)); - let mut gateway = Gateway { events: Arc::new(Mutex::new(Events::default())), heartbeat_handler: None, websocket_tx: shared_tx.clone() }; + let mut gateway = Gateway { + events: Arc::new(Mutex::new(Events::default())), + heartbeat_handler: None, + websocket_tx: shared_tx.clone(), + }; let shared_events = gateway.events.clone(); @@ -134,13 +184,20 @@ impl Gateway { if gateway_payload.op != 10 { println!("Recieved non hello on gateway init, what is happening?"); - return Err(tokio_tungstenite::tungstenite::Error::Protocol(tokio_tungstenite::tungstenite::error::ProtocolError::InvalidOpcode(gateway_payload.op))) + return Err(tokio_tungstenite::tungstenite::Error::Protocol( + tokio_tungstenite::tungstenite::error::ProtocolError::InvalidOpcode( + gateway_payload.op, + ), + )); } println!("GW: Received Hello"); 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())); + 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 task::spawn(async move { @@ -162,7 +219,6 @@ impl Gateway { /// This handles a message as a websocket event and updates its events along with the events' observers pub async fn handle_event(&mut self, msg: tokio_tungstenite::tungstenite::Message) { - if msg.to_string() == String::new() { return; } @@ -183,7 +239,8 @@ impl Gateway { // See https://discord.com/developers/docs/topics/gateway-events#receive-events match gateway_payload_t.as_str() { "READY" => { - let _data: GatewayReady = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let _data: GatewayReady = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); } "RESUMED" => {} "APPLICATION_COMMAND_PERMISSIONS_UPDATE" => {} @@ -192,65 +249,144 @@ impl Gateway { "AUTO_MODERATION_RULE_DELETE" => {} "AUTO_MODERATION_ACTION_EXECUTION" => {} "CHANNEL_CREATE" => { - let channel: Channel = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); - let new_data = ChannelCreate {channel}; - self.events.lock().await.channel.create.update_data(new_data).await; + let channel: Channel = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let new_data = ChannelCreate { channel }; + self.events + .lock() + .await + .channel + .create + .update_data(new_data) + .await; } "CHANNEL_UPDATE" => { - let channel: Channel = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); - let new_data = ChannelUpdate {channel}; - self.events.lock().await.channel.update.update_data(new_data).await; + let channel: Channel = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let new_data = ChannelUpdate { channel }; + self.events + .lock() + .await + .channel + .update + .update_data(new_data) + .await; } "CHANNEL_DELETE" => { - let channel: Channel = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); - let new_data = ChannelDelete {channel}; - self.events.lock().await.channel.delete.update_data(new_data).await; + let channel: Channel = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let new_data = ChannelDelete { channel }; + self.events + .lock() + .await + .channel + .delete + .update_data(new_data) + .await; } "CHANNEL_PINS_UPDATE" => { - 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; + 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; } "THREAD_CREATE" => { - let thread: Channel = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); - let new_data = ThreadCreate {thread}; - self.events.lock().await.thread.create.update_data(new_data).await; + let thread: Channel = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let new_data = ThreadCreate { thread }; + self.events + .lock() + .await + .thread + .create + .update_data(new_data) + .await; } "THREAD_UPDATE" => { - let thread: Channel = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); - let new_data = ThreadUpdate {thread}; - self.events.lock().await.thread.update.update_data(new_data).await; + let thread: Channel = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let new_data = ThreadUpdate { thread }; + self.events + .lock() + .await + .thread + .update + .update_data(new_data) + .await; } "THREAD_DELETE" => { - let thread: Channel = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); - let new_data = ThreadDelete {thread}; - self.events.lock().await.thread.delete.update_data(new_data).await; + let thread: Channel = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let new_data = ThreadDelete { thread }; + self.events + .lock() + .await + .thread + .delete + .update_data(new_data) + .await; } "THREAD_LIST_SYNC" => { - 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; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.thread.member_update.update_data(new_data).await; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.thread.members_update.update_data(new_data).await; + 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(&msg_string).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_DELETE" => { - let _new_data: UnavailableGuild = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let _new_data: UnavailableGuild = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); } "GUILD_AUDIT_LOG_ENTRY_CREATE" => {} "GUILD_BAN_ADD" => { - let _new_data: GuildBanAdd = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let _new_data: GuildBanAdd = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); } "GUILD_BAN_REMOVE" => { - let _new_data: GuildBanRemove = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let _new_data: GuildBanRemove = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); } "GUILD_EMOJIS_UPDATE" => {} "GUILD_STICKERS_UPDATE" => {} @@ -274,40 +410,103 @@ impl Gateway { "INVITE_CREATE" => {} "INVITE_DELETE" => {} "MESSAGE_CREATE" => { - let new_data: MessageCreate = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.message.create.update_data(new_data).await; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.message.update.update_data(new_data).await; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.message.delete.update_data(new_data).await; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.message.delete_bulk.update_data(new_data).await; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.message.reaction_add.update_data(new_data).await; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.message.reaction_remove.update_data(new_data).await; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.message.reaction_remove_all.update_data(new_data).await; + 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_value(gateway_payload.d.unwrap()).unwrap(); - self.events.lock().await.message.reaction_remove_emoji.update_data(new_data).await; + 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; } "PRESENCE_UPDATE" => { - 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; + 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; } "STAGE_INSTANCE_CREATE" => {} "STAGE_INSTANCE_UPDATE" => {} @@ -315,27 +514,47 @@ impl Gateway { // Not documented in discord docs, I assume this isnt for bots / apps but is for users? "SESSIONS_REPLACE" => {} "TYPING_START" => { - 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; + 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 user: UserObject = serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); - let new_data = UserUpdate {user}; - self.events.lock().await.user.update.update_data(new_data).await; + let user: User = + serde_json::from_value(gateway_payload.d.unwrap()).unwrap(); + let new_data = UserUpdate { user }; + self.events + .lock() + .await + .user + .update + .update_data(new_data) + .await; } "VOICE_STATE_UPDATE" => {} "VOICE_SERVER_UPDATE" => {} "WEBHOOKS_UPDATE" => {} - _ => {panic!("Invalid gateway event ({})", &gateway_payload_t)} + _ => { + panic!("Invalid gateway event ({})", &gateway_payload_t) + } } } // Heartbeat // We received a heartbeat from the server 1 => {} // Reconnect - 7 => {todo!()} + 7 => { + todo!() + } // Invalid Session - 9 => {todo!()} + 9 => { + todo!() + } // Hello // Starts our heartbeat // We should have already handled this in gateway init @@ -346,17 +565,32 @@ impl Gateway { 11 => { println!("GW: Received Heartbeat ACK"); } - 2 | 3 | 4 | 6 | 8 => {panic!("Received Gateway op code that's meant to be sent, not received ({})", gateway_payload.op)} - _ => {panic!("Received Invalid Gateway op code ({})", gateway_payload.op)} + 2 | 3 | 4 | 6 | 8 => { + panic!( + "Received Gateway op code that's meant to be sent, not received ({})", + gateway_payload.op + ) + } + _ => { + panic!("Received Invalid Gateway op code ({})", gateway_payload.op) + } } // If we have an active heartbeat thread and we received a seq number we should let it know if gateway_payload.s.is_some() { if self.heartbeat_handler.is_some() { + let heartbeat_communication = HeartbeatThreadCommunication { + op: gateway_payload.op, + d: gateway_payload.s.unwrap(), + }; - let heartbeat_communication = HeartbeatThreadCommunication { op: gateway_payload.op, d: gateway_payload.s.unwrap() }; - - self.heartbeat_handler.as_mut().unwrap().tx.send(heartbeat_communication).await.unwrap(); + self.heartbeat_handler + .as_mut() + .unwrap() + .tx + .send(heartbeat_communication) + .await + .unwrap(); } } } @@ -372,7 +606,17 @@ struct HeartbeatHandler { } impl HeartbeatHandler { - pub fn new(heartbeat_interval: u128, websocket_tx: Arc>, tokio_tungstenite::tungstenite::Message>>>) -> HeartbeatHandler { + pub fn new( + heartbeat_interval: u128, + websocket_tx: Arc< + Mutex< + SplitSink< + WebSocketStream>, + tokio_tungstenite::tungstenite::Message, + >, + >, + >, + ) -> HeartbeatHandler { let (tx, mut rx) = mpsc::channel(32); task::spawn(async move { @@ -380,37 +624,36 @@ impl HeartbeatHandler { let mut last_seq_number: Option = None; loop { - // If we received a seq number update, use that as the last seq number - let hb_communication: Result = rx.try_recv(); + let hb_communication: Result = + rx.try_recv(); if hb_communication.is_ok() { last_seq_number = Some(hb_communication.unwrap().d); } if last_heartbeat.elapsed().as_millis() > heartbeat_interval { - println!("GW: Sending Heartbeat.."); let heartbeat = GatewayHeartbeat { op: 1, - d: last_seq_number + d: last_seq_number, }; let heartbeat_json = serde_json::to_string(&heartbeat).unwrap(); let msg = tokio_tungstenite::tungstenite::Message::text(heartbeat_json); - websocket_tx.lock().await - .send(msg) - .await - .unwrap(); + websocket_tx.lock().await.send(msg).await.unwrap(); last_heartbeat = time::Instant::now(); } } }); - Self { heartbeat_interval, tx } + Self { + heartbeat_interval, + tx, + } } } @@ -423,7 +666,7 @@ struct HeartbeatThreadCommunication { /// An opcode for the communication we received op: u8, /// The sequence number we got from discord - d: u64 + d: u64, } /** @@ -469,7 +712,10 @@ impl GatewayEvent { Returns an error if the GatewayEvent is already observed. Error type: [`ObserverError::AlreadySubscribedError`] */ - pub fn subscribe(&mut self, observable: Arc + Sync + Send>>) -> Option { + pub fn subscribe( + &mut self, + observable: Arc + Sync + Send>>, + ) -> Option { if self.is_observed { return Some(ObserverError::AlreadySubscribedError); } @@ -486,7 +732,8 @@ impl GatewayEvent { // pointer value than observable. // The usage of the debug format to compare the generic T of observers is quite stupid, but the only thing to compare between them is T and if T == T they are the same // anddd there is no way to do that without using format - self.observers.retain(|obs| !(format!("{:?}", obs) == format!("{:?}", &observable))); + self.observers + .retain(|obs| !(format!("{:?}", obs) == format!("{:?}", &observable))); self.is_observed = !self.observers.is_empty(); } @@ -545,7 +792,7 @@ mod events { pub create: GatewayEvent, pub update: GatewayEvent, pub delete: GatewayEvent, - pub pins_update: GatewayEvent + pub pins_update: GatewayEvent, } #[derive(Default, Debug)] @@ -587,7 +834,6 @@ mod events { #[cfg(test)] mod example { use super::*; - use crate::api::types::GatewayResume; #[derive(Debug)] struct Consumer; @@ -634,7 +880,6 @@ mod example { None => assert!(true), Some(_) => assert!(false), } - } #[tokio::test] diff --git a/src/instance.rs b/src/instance.rs index ab4b4b2..b820815 100644 --- a/src/instance.rs +++ b/src/instance.rs @@ -1,9 +1,11 @@ use crate::api::limits::Limits; -use crate::api::types::InstancePolicies; use crate::errors::{FieldFormatError, InstanceServerError}; +use crate::types::{GeneralConfiguration, User, UserSettings}; use crate::URLBundle; +use std::cell::RefCell; use std::fmt; +use std::rc::Rc; #[derive(Debug, Clone)] /** @@ -11,7 +13,7 @@ The [`Instance`] what you will be using to perform all sorts of actions on the S */ pub struct Instance { pub urls: URLBundle, - pub instance_info: InstancePolicies, + pub instance_info: GeneralConfiguration, pub limits: Limits, } @@ -25,7 +27,7 @@ impl Instance { pub async fn new(urls: URLBundle) -> Result { let mut instance = Instance { urls: urls.clone(), - instance_info: InstancePolicies::new( + instance_info: GeneralConfiguration::new( // This is okay, because the instance_info will be overwritten by the instance_policies_schema() function. "".to_string(), None, @@ -38,7 +40,7 @@ impl Instance { ), limits: Limits::check_limits(urls.api).await, }; - instance.instance_info = match instance.instance_policies_schema().await { + instance.instance_info = match instance.general_configuration_schema().await { Ok(schema) => schema, Err(e) => { return Err(InstanceServerError::CantGetInfoError { @@ -79,3 +81,38 @@ impl Username { Ok(Username { username }) } } + +#[derive(Debug)] +pub struct UserMeta { + pub belongs_to: Rc>, + pub token: String, + pub limits: Limits, + pub settings: UserSettings, + pub object: Option, +} + +impl UserMeta { + pub fn token(&self) -> String { + self.token.clone() + } + + pub fn set_token(&mut self, token: String) { + self.token = token; + } + + pub fn new( + belongs_to: Rc>, + token: String, + limits: Limits, + settings: UserSettings, + object: Option, + ) -> UserMeta { + UserMeta { + belongs_to, + token, + limits, + settings, + object, + } + } +} diff --git a/src/types/config/types/general_configuration.rs b/src/types/config/types/general_configuration.rs index e30e29e..a3c8f65 100644 --- a/src/types/config/types/general_configuration.rs +++ b/src/types/config/types/general_configuration.rs @@ -13,7 +13,6 @@ pub struct GeneralConfiguration { pub correspondence_user_id: Option, pub image: Option, pub instance_id: Option, - pub auto_create_bot_users: Option, } impl Default for GeneralConfiguration { @@ -29,7 +28,30 @@ impl Default for GeneralConfiguration { correspondence_user_id: None, image: None, instance_id: Some(Snowflake::generate()), - auto_create_bot_users: Some(false), + } + } +} + +impl GeneralConfiguration { + pub fn new( + instance_name: String, + instance_description: Option, + front_page: Option, + tos_page: Option, + correspondence_email: Option, + correspondence_user_id: Option, + image: Option, + instance_id: Option, + ) -> Self { + Self { + instance_name, + instance_description, + front_page, + tos_page, + correspondence_email, + correspondence_user_id, + image, + instance_id, } } } diff --git a/src/types/mod.rs b/src/types/mod.rs index 9148416..8554011 100644 --- a/src/types/mod.rs +++ b/src/types/mod.rs @@ -1,4 +1,5 @@ pub use config::*; +pub use entities::*; pub use errors::*; pub use events::*; pub use interfaces::*; diff --git a/types/entities/user.rs b/types/entities/user.rs index 9ff7949..ce3563c 100644 --- a/types/entities/user.rs +++ b/types/entities/user.rs @@ -9,63 +9,6 @@ use crate::{ utils::Snowflake, //util::{email::adjust_email, entities::user_setting::UserSettings}, }; -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -#[cfg_attr(feature = "sqlx", derive(FromRow))] -pub struct User { - pub id: Snowflake, - pub username: String, - pub discriminator: String, - pub avatar: Option, - pub accent_color: Option, - pub banner: Option, - pub theme_colors: Option>, - pub pronouns: Option, - pub phone: Option, - pub desktop: bool, - pub mobile: bool, - pub premium: bool, - pub premium_type: u8, - pub bot: bool, - pub bio: String, - pub system: bool, - pub nsfw_allowed: bool, - pub mfa_enabled: bool, - pub webauthn_enabled: bool, - #[serde(skip)] - pub totp_secret: Option, - #[serde(skip)] - pub totp_last_ticket: Option, - pub created_at: DateTime, - pub premium_since: Option>, - pub verified: bool, - pub disabled: bool, - pub deleted: bool, - pub email: Option, - pub flags: String, - pub public_flags: u16, - pub purchased_flags: u16, - pub premium_usage_flags: u16, - pub rights: String, - #[cfg(feature = "sqlx")] - pub relationship_ids: sqlx::types::Json>, - #[cfg(not(feature = "sqlx"))] - pub relationship_ids: Vec, - #[cfg(feature = "sqlx")] - pub connected_account_ids: sqlx::types::Json>, - #[cfg(not(feature = "sqlx"))] - pub connected_account_ids: Vec, - #[cfg(feature = "sqlx")] - pub data: sqlx::types::Json, - #[cfg(not(feature = "sqlx"))] - pub data: UserData, - #[cfg(feature = "sqlx")] - pub fingerprints: sqlx::types::Json>, - #[cfg(not(feature = "sqlx"))] - pub fingerprints: Vec, - // pub settings: UserSettings, - pub extended_settings: Value, -} - #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Default)] #[cfg_attr(feature = "sqlx", derive(Type))] pub struct UserData { @@ -73,77 +16,8 @@ pub struct UserData { pub hash: Option, } -impl Default for User { - fn default() -> Self { - Self { - id: Snowflake::generate(), - username: String::new(), - discriminator: String::new(), - avatar: None, - accent_color: None, - banner: None, - theme_colors: None, - pronouns: None, - phone: None, - desktop: false, - mobile: false, - premium: false, - premium_type: 0, - bot: false, - bio: String::new(), - system: false, - nsfw_allowed: false, - mfa_enabled: false, - webauthn_enabled: false, - totp_secret: None, - totp_last_ticket: None, - created_at: Utc::now(), - premium_since: None, - verified: false, - disabled: false, - deleted: false, - email: None, - flags: String::from("0"), - public_flags: 0, - purchased_flags: 0, - premium_usage_flags: 0, - rights: String::new(), - relationship_ids: Default::default(), - connected_account_ids: Default::default(), - data: Default::default(), - fingerprints: Default::default(), - //settings: UserSettings::default(), - extended_settings: Value::Object(Map::new()), - } - } -} - -impl User { - pub fn validate(&mut self) -> Result<(), Error> { - /*if let Some(email) = self.email.as_ref() { - self.email = Some(adjust_email(email)?); - } - - if self.discriminator.len() < 4 { - self.discriminator = format!("{:0>4}", self.discriminator); - } - Ok(())*/ - todo!() - } - - pub async fn generate_discriminator(_username: &str) -> Result { - todo!() - } -} - -impl User { - pub fn to_public_user(self) -> PublicUser { - PublicUser::from(self) - } -} - #[derive(Serialize, Deserialize, Debug, Default, Clone)] -pub struct PrivateUser { +pub struct User { pub id: String, username: String, discriminator: String, @@ -172,7 +46,7 @@ pub struct PrivateUser { } #[derive(Debug, Clone, PartialEq, Serialize, Deserialize)] -pub struct PublicUser { +pub struct User { pub id: Snowflake, pub username: String, pub discriminator: String,