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

Prettify imports, remove outdated types/schemas

This commit is contained in:
bitfl0wer 2023-05-26 12:59:32 +02:00
parent ba93db0be8
commit 3353a2f461
4 changed files with 79 additions and 2029 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/api/guilds/guilds.rs
View File

@ -6,11 +6,7 @@ use crate::api::limits::Limits;
use crate::errors::InstanceServerError;
use crate::instance::UserMeta;
use crate::limit::LimitedRequester;
use crate::types::Channel;
use crate::types::ChannelCreateSchema;
use crate::types::Guild;
use crate::types::GuildCreateResponse;
use crate::types::GuildCreateSchema;
use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateResponse, GuildCreateSchema};
impl Guild {
/// Creates a new guild with the given parameters.

432
src/api/schemas.rs
View File

@ -1,432 +0,0 @@
use regex::Regex;
use serde::{Deserialize, Serialize};
use crate::errors::FieldFormatError;
use super::{Channel, Embed};
/**
A struct that represents a well-formed email address.
*/
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct AuthEmail {
pub email: String,
}
impl AuthEmail {
/**
Returns a new [`Result<AuthEmail, FieldFormatError>`].
## Arguments
The email address you want to validate.
## Errors
You will receive a [`FieldFormatError`], if:
- The email address is not in a valid format.
*/
pub fn new(email: String) -> Result<AuthEmail, FieldFormatError> {
let regex = Regex::new(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$").unwrap();
if !regex.is_match(email.as_str()) {
return Err(FieldFormatError::EmailError);
}
Ok(AuthEmail { email })
}
}
/**
A struct that represents a well-formed username.
## Arguments
Please use new() to create a new instance of this struct.
## Errors
You will receive a [`FieldFormatError`], if:
- The username is not between 2 and 32 characters.
*/
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct AuthUsername {
pub username: String,
}
impl AuthUsername {
/**
Returns a new [`Result<AuthUsername, FieldFormatError>`].
## Arguments
The username you want to validate.
## Errors
You will receive a [`FieldFormatError`], if:
- The username is not between 2 and 32 characters.
*/
pub fn new(username: String) -> Result<AuthUsername, FieldFormatError> {
if username.len() < 2 || username.len() > 32 {
Err(FieldFormatError::UsernameError)
} else {
Ok(AuthUsername { username })
}
}
}
/**
A struct that represents a well-formed password.
## Arguments
Please use new() to create a new instance of this struct.
## Errors
You will receive a [`FieldFormatError`], if:
- The password is not between 1 and 72 characters.
*/
#[derive(Clone, PartialEq, Eq, Debug)]
pub struct AuthPassword {
pub password: String,
}
impl AuthPassword {
/**
Returns a new [`Result<AuthPassword, FieldFormatError>`].
## Arguments
The password you want to validate.
## Errors
You will receive a [`FieldFormatError`], if:
- The password is not between 1 and 72 characters.
*/
pub fn new(password: String) -> Result<AuthPassword, FieldFormatError> {
if password.is_empty() || password.len() > 72 {
Err(FieldFormatError::PasswordError)
} else {
Ok(AuthPassword { password })
}
}
}
/**
A struct that represents a well-formed register request.
## Arguments
Please use new() to create a new instance of this struct.
## Errors
You will receive a [`FieldFormatError`], if:
- The username is not between 2 and 32 characters.
- The password is not between 1 and 72 characters.
*/
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub struct RegisterSchema {
username: String,
password: Option<String>,
consent: bool,
email: Option<String>,
fingerprint: Option<String>,
invite: Option<String>,
date_of_birth: Option<String>,
gift_code_sku_id: Option<String>,
captcha_key: Option<String>,
promotional_email_opt_in: Option<bool>,
}
impl RegisterSchema {
/**
Returns a new [`Result<RegisterSchema, FieldFormatError>`].
## Arguments
All but "String::username" and "bool::consent" are optional.
## Errors
You will receive a [`FieldFormatError`], if:
- The username is less than 2 or more than 32 characters in length
- You supply a `password` which is less than 1 or more than 72 characters in length.
These constraints have been defined [in the Spacebar-API](https://docs.spacebar.chat/routes/)
*/
pub fn new(
username: AuthUsername,
password: Option<AuthPassword>,
consent: bool,
email: Option<AuthEmail>,
fingerprint: Option<String>,
invite: Option<String>,
date_of_birth: Option<String>,
gift_code_sku_id: Option<String>,
captcha_key: Option<String>,
promotional_email_opt_in: Option<bool>,
) -> Result<RegisterSchema, FieldFormatError> {
let username = username.username;
let email_addr;
if email.is_some() {
email_addr = Some(email.unwrap().email);
} else {
email_addr = None;
}
let has_password;
if password.is_some() {
has_password = Some(password.unwrap().password);
} else {
has_password = None;
}
if !consent {
return Err(FieldFormatError::ConsentError);
}
Ok(RegisterSchema {
username,
password: has_password,
consent,
email: email_addr,
fingerprint,
invite,
date_of_birth,
gift_code_sku_id,
captcha_key,
promotional_email_opt_in,
})
}
}
/**
A struct that represents a well-formed login request.
## Arguments
Please use new() to create a new instance of this struct.
## Errors
You will receive a [`FieldFormatError`], if:
- The username is not between 2 and 32 characters.
- The password is not between 1 and 72 characters.
*/
#[derive(Debug, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub struct LoginSchema {
login: String,
password: String,
undelete: Option<bool>,
captcha_key: Option<String>,
login_source: Option<String>,
gift_code_sku_id: Option<String>,
}
impl LoginSchema {
/**
Returns a new [`Result<LoginSchema, FieldFormatError>`].
## Arguments
login: The username you want to login with.
password: The password you want to login with.
undelete: Honestly no idea what this is for.
captcha_key: The captcha key you want to login with.
login_source: The login source.
gift_code_sku_id: The gift code sku id.
## Errors
You will receive a [`FieldFormatError`], if:
- The username is less than 2 or more than 32 characters in length
*/
pub fn new(
login: AuthUsername,
password: String,
undelete: Option<bool>,
captcha_key: Option<String>,
login_source: Option<String>,
gift_code_sku_id: Option<String>,
) -> Result<LoginSchema, FieldFormatError> {
let login = login.username;
Ok(LoginSchema {
login,
password,
undelete,
captcha_key,
login_source,
gift_code_sku_id,
})
}
}
#[derive(Debug, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub struct TotpSchema {
code: String,
ticket: String,
gift_code_sku_id: Option<String>,
login_source: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub struct MessageSendSchema {
#[serde(rename = "type")]
message_type: Option<i32>,
content: Option<String>,
nonce: Option<String>,
tts: Option<bool>,
embeds: Option<Vec<super::Embed>>,
allowed_mentions: Option<super::AllowedMention>,
message_reference: Option<super::MessageReference>,
components: Option<Vec<super::Component>>,
sticker_ids: Option<Vec<String>>,
pub attachments: Option<Vec<super::PartialDiscordFileAttachment>>,
}
// make a new() method for MessageSendSchema
impl MessageSendSchema {
pub fn new(
message_type: Option<i32>,
content: Option<String>,
nonce: Option<String>,
tts: Option<bool>,
embeds: Option<Vec<Embed>>,
allowed_mentions: Option<super::AllowedMention>,
message_reference: Option<super::MessageReference>,
components: Option<Vec<super::Component>>,
sticker_ids: Option<Vec<String>>,
attachments: Option<Vec<super::PartialDiscordFileAttachment>>,
) -> MessageSendSchema {
MessageSendSchema {
message_type,
content,
nonce,
tts,
embeds,
allowed_mentions,
message_reference,
components,
sticker_ids,
attachments,
}
}
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub struct GuildCreateSchema {
pub name: Option<String>,
pub region: Option<String>,
pub icon: Option<String>,
pub channels: Option<Vec<Channel>>,
pub guild_template_code: Option<String>,
pub system_channel_id: Option<String>,
pub rules_channel_id: Option<String>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
pub struct UserModifySchema {
pub username: Option<String>,
pub avatar: Option<String>,
pub bio: Option<String>,
pub accent_color: Option<u64>,
pub banner: Option<String>,
pub current_password: Option<String>,
pub new_password: Option<String>,
pub code: Option<String>,
pub email: Option<String>,
pub discriminator: Option<i16>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
// TODO: Implement in polyphony/types
pub struct ChannelCreateSchema {
pub name: String,
#[serde(rename = "type")]
pub channel_type: Option<u8>,
pub topic: Option<String>,
pub icon: Option<String>,
pub bitrate: Option<i32>,
pub user_limit: Option<i32>,
pub rate_limit_per_user: Option<i32>,
pub position: Option<i32>,
pub permission_overwrites: Option<Vec<crate::api::types::PermissionOverwrite>>,
pub parent_id: Option<String>,
pub id: Option<String>,
pub nsfw: Option<bool>,
pub rtc_region: Option<String>,
pub default_auto_archive_duration: Option<i32>,
pub default_reaction_emoji: Option<String>,
pub flags: Option<i32>,
pub default_thread_rate_limit_per_user: Option<i32>,
pub video_quality_mode: Option<i32>,
}
// I know that some of these tests are... really really basic and unneccessary, but sometimes, I
// just feel like writing tests, so there you go :) -@bitfl0wer
#[cfg(test)]
mod schemas_tests {
use super::*;
use crate::errors::FieldFormatError;
#[test]
fn password_too_short() {
assert_eq!(
AuthPassword::new("".to_string()),
Err(FieldFormatError::PasswordError)
);
}
#[test]
fn password_too_long() {
let mut long_pw = String::new();
for _ in 0..73 {
long_pw += "a";
}
assert_eq!(
AuthPassword::new(long_pw),
Err(FieldFormatError::PasswordError)
);
}
#[test]
fn username_too_short() {
assert_eq!(
AuthUsername::new("T".to_string()),
Err(FieldFormatError::UsernameError)
);
}
#[test]
fn username_too_long() {
let mut long_un = String::new();
for _ in 0..33 {
long_un += "a";
}
assert_eq!(
AuthUsername::new(long_un),
Err(FieldFormatError::UsernameError)
);
}
#[test]
fn consent_false() {
assert_eq!(
RegisterSchema::new(
AuthUsername::new("Test".to_string()).unwrap(),
None,
false,
None,
None,
None,
None,
None,
None,
None,
),
Err(FieldFormatError::ConsentError)
);
}
#[test]
fn invalid_email() {
assert_eq!(
AuthEmail::new("p@p.p".to_string()),
Err(FieldFormatError::EmailError)
)
}
#[test]
fn valid_email() {
let reg = RegisterSchema::new(
AuthUsername::new("Testy".to_string()).unwrap(),
None,
true,
Some(AuthEmail::new("me@mail.de".to_string()).unwrap()),
None,
None,
None,
None,
None,
None,
);
assert_ne!(reg, Err(FieldFormatError::EmailError));
}
}

1482
src/api/types.rs
View File

File diff suppressed because it is too large Load Diff

188
src/gateway.rs
View File

@ -1,41 +1,6 @@
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 crate::types;
use futures_util::stream::SplitSink;
use futures_util::SinkExt;
use futures_util::StreamExt;
@ -75,7 +40,7 @@ pub struct GatewayHandle {
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 {
let gateway_payload = types::GatewayPayload {
op,
d: Some(to_send),
s: None,
@ -90,7 +55,7 @@ impl GatewayHandle {
}
/// Sends an identify event to the gateway
pub async fn send_identify(&self, to_send: GatewayIdentifyPayload) {
pub async fn send_identify(&self, to_send: types::GatewayIdentifyPayload) {
let to_send_value = serde_json::to_value(&to_send).unwrap();
println!("GW: Sending Identify..");
@ -99,7 +64,7 @@ impl GatewayHandle {
}
/// Sends a resume event to the gateway
pub async fn send_resume(&self, to_send: GatewayResume) {
pub async fn send_resume(&self, to_send: types::GatewayResume) {
let to_send_value = serde_json::to_value(&to_send).unwrap();
println!("GW: Sending Resume..");
@ -108,7 +73,7 @@ impl GatewayHandle {
}
/// 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: types::PresenceUpdate) {
let to_send_value = serde_json::to_value(&to_send).unwrap();
println!("GW: Sending Presence Update..");
@ -117,7 +82,7 @@ impl GatewayHandle {
}
/// 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: types::GatewayRequestGuildMembers) {
let to_send_value = serde_json::to_value(&to_send).unwrap();
println!("GW: Sending Request Guild Members..");
@ -126,7 +91,7 @@ impl GatewayHandle {
}
/// 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: types::GatewayVoiceStateUpdate) {
let to_send_value = serde_json::to_value(&to_send).unwrap();
println!("GW: Sending Voice State Update..");
@ -180,7 +145,8 @@ impl Gateway {
// Wait for the first hello and then spawn both tasks so we avoid nested tasks
// This automatically spawns the heartbeat task, but from the main thread
let msg = ws_rx.next().await.unwrap().unwrap();
let gateway_payload: GatewayPayload = serde_json::from_str(msg.to_text().unwrap()).unwrap();
let gateway_payload: types::GatewayPayload =
serde_json::from_str(msg.to_text().unwrap()).unwrap();
if gateway_payload.op != 10 {
println!("Recieved non hello on gateway init, what is happening?");
@ -193,7 +159,8 @@ impl Gateway {
println!("GW: Received Hello");
let gateway_hello: HelloData = serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
let gateway_hello: types::HelloData =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
gateway.heartbeat_handler = Some(HeartbeatHandler::new(
gateway_hello.heartbeat_interval,
shared_tx.clone(),
@ -225,7 +192,7 @@ impl Gateway {
let msg_string = msg.to_string();
let gateway_payload: GatewayPayload = serde_json::from_str(&msg_string).unwrap();
let gateway_payload: types::GatewayPayload = serde_json::from_str(&msg_string).unwrap();
// See https://discord.com/developers/docs/topics/opcodes-and-status-codes#gateway-gateway-opcodes
match gateway_payload.op {
@ -239,7 +206,7 @@ impl Gateway {
// See https://discord.com/developers/docs/topics/gateway-events#receive-events
match gateway_payload_t.as_str() {
"READY" => {
let _data: GatewayReady =
let _data: types::GatewayReady =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
}
"RESUMED" => {}
@ -249,9 +216,9 @@ impl Gateway {
"AUTO_MODERATION_RULE_DELETE" => {}
"AUTO_MODERATION_ACTION_EXECUTION" => {}
"CHANNEL_CREATE" => {
let channel: Channel =
let channel: types::Channel =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
let new_data = ChannelCreate { channel };
let new_data = types::ChannelCreate { channel };
self.events
.lock()
.await
@ -261,9 +228,9 @@ impl Gateway {
.await;
}
"CHANNEL_UPDATE" => {
let channel: Channel =
let channel: types::Channel =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
let new_data = ChannelUpdate { channel };
let new_data = types::ChannelUpdate { channel };
self.events
.lock()
.await
@ -273,9 +240,9 @@ impl Gateway {
.await;
}
"CHANNEL_DELETE" => {
let channel: Channel =
let channel: types::Channel =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
let new_data = ChannelDelete { channel };
let new_data = types::ChannelDelete { channel };
self.events
.lock()
.await
@ -285,7 +252,7 @@ impl Gateway {
.await;
}
"CHANNEL_PINS_UPDATE" => {
let new_data: ChannelPinsUpdate =
let new_data: types::ChannelPinsUpdate =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -296,9 +263,9 @@ impl Gateway {
.await;
}
"THREAD_CREATE" => {
let thread: Channel =
let thread: types::Channel =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
let new_data = ThreadCreate { thread };
let new_data = types::ThreadCreate { thread };
self.events
.lock()
.await
@ -308,9 +275,9 @@ impl Gateway {
.await;
}
"THREAD_UPDATE" => {
let thread: Channel =
let thread: types::Channel =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
let new_data = ThreadUpdate { thread };
let new_data = types::ThreadUpdate { thread };
self.events
.lock()
.await
@ -320,9 +287,9 @@ impl Gateway {
.await;
}
"THREAD_DELETE" => {
let thread: Channel =
let thread: types::Channel =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
let new_data = ThreadDelete { thread };
let new_data = types::ThreadDelete { thread };
self.events
.lock()
.await
@ -332,7 +299,7 @@ impl Gateway {
.await;
}
"THREAD_LIST_SYNC" => {
let new_data: ThreadListSync =
let new_data: types::ThreadListSync =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -343,7 +310,7 @@ impl Gateway {
.await;
}
"THREAD_MEMBER_UPDATE" => {
let new_data: ThreadMemberUpdate =
let new_data: types::ThreadMemberUpdate =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -354,7 +321,7 @@ impl Gateway {
.await;
}
"THREAD_MEMBERS_UPDATE" => {
let new_data: ThreadMembersUpdate =
let new_data: types::ThreadMembersUpdate =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -365,7 +332,8 @@ impl Gateway {
.await;
}
"GUILD_CREATE" => {
let new_data: GuildCreate = serde_json::from_str(&msg_string).unwrap();
let new_data: types::GuildCreate =
serde_json::from_str(&msg_string).unwrap();
self.events
.lock()
.await
@ -376,16 +344,16 @@ impl Gateway {
}
"GUILD_UPDATE" => {}
"GUILD_DELETE" => {
let _new_data: UnavailableGuild =
let _new_data: types::UnavailableGuild =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
}
"GUILD_AUDIT_LOG_ENTRY_CREATE" => {}
"GUILD_BAN_ADD" => {
let _new_data: GuildBanAdd =
let _new_data: types::GuildBanAdd =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
}
"GUILD_BAN_REMOVE" => {
let _new_data: GuildBanRemove =
let _new_data: types::GuildBanRemove =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
}
"GUILD_EMOJIS_UPDATE" => {}
@ -410,7 +378,7 @@ impl Gateway {
"INVITE_CREATE" => {}
"INVITE_DELETE" => {}
"MESSAGE_CREATE" => {
let new_data: MessageCreate =
let new_data: types::MessageCreate =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -421,7 +389,7 @@ impl Gateway {
.await;
}
"MESSAGE_UPDATE" => {
let new_data: MessageUpdate =
let new_data: types::MessageUpdate =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -432,7 +400,7 @@ impl Gateway {
.await;
}
"MESSAGE_DELETE" => {
let new_data: MessageDelete =
let new_data: types::MessageDelete =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -443,7 +411,7 @@ impl Gateway {
.await;
}
"MESSAGE_DELETE_BULK" => {
let new_data: MessageDeleteBulk =
let new_data: types::MessageDeleteBulk =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -454,7 +422,7 @@ impl Gateway {
.await;
}
"MESSAGE_REACTION_ADD" => {
let new_data: MessageReactionAdd =
let new_data: types::MessageReactionAdd =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -465,7 +433,7 @@ impl Gateway {
.await;
}
"MESSAGE_REACTION_REMOVE" => {
let new_data: MessageReactionRemove =
let new_data: types::MessageReactionRemove =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -476,7 +444,7 @@ impl Gateway {
.await;
}
"MESSAGE_REACTION_REMOVE_ALL" => {
let new_data: MessageReactionRemoveAll =
let new_data: types::MessageReactionRemoveAll =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -487,7 +455,7 @@ impl Gateway {
.await;
}
"MESSAGE_REACTION_REMOVE_EMOJI" => {
let new_data: MessageReactionRemoveEmoji =
let new_data: types::MessageReactionRemoveEmoji =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -498,7 +466,7 @@ impl Gateway {
.await;
}
"PRESENCE_UPDATE" => {
let new_data: PresenceUpdate =
let new_data: types::PresenceUpdate =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -514,7 +482,7 @@ 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 =
let new_data: types::TypingStartEvent =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
self.events
.lock()
@ -525,9 +493,9 @@ impl Gateway {
.await;
}
"USER_UPDATE" => {
let user: User =
let user: types::User =
serde_json::from_value(gateway_payload.d.unwrap()).unwrap();
let new_data = UserUpdate { user };
let new_data = types::UserUpdate { user };
self.events
.lock()
.await
@ -634,7 +602,7 @@ impl HeartbeatHandler {
if last_heartbeat.elapsed().as_millis() > heartbeat_interval {
println!("GW: Sending Heartbeat..");
let heartbeat = GatewayHeartbeat {
let heartbeat = types::GatewayHeartbeat {
op: 1,
d: last_seq_number,
};
@ -674,7 +642,7 @@ Trait which defines the behaviour of an Observer. An Observer is an object which
an Observable. The Observer is notified when the Observable's data changes.
In this case, the Observable is a [`GatewayEvent`], which is a wrapper around a WebSocketEvent.
*/
pub trait Observer<T: WebSocketEvent>: std::fmt::Debug {
pub trait Observer<T: types::WebSocketEvent>: std::fmt::Debug {
fn update(&self, data: &T);
}
@ -683,13 +651,13 @@ change in the WebSocketEvent. GatewayEvents are observable.
*/
#[derive(Default, Debug)]
pub struct GatewayEvent<T: WebSocketEvent> {
pub struct GatewayEvent<T: types::WebSocketEvent> {
observers: Vec<Arc<Mutex<dyn Observer<T> + Sync + Send>>>,
pub event_data: T,
pub is_observed: bool,
}
impl<T: WebSocketEvent> GatewayEvent<T> {
impl<T: types::WebSocketEvent> GatewayEvent<T> {
fn new(event_data: T) -> Self {
Self {
is_observed: false,
@ -764,50 +732,50 @@ mod events {
pub channel: Channel,
pub thread: Thread,
pub guild: Guild,
pub gateway_identify_payload: GatewayEvent<GatewayIdentifyPayload>,
pub gateway_resume: GatewayEvent<GatewayResume>,
pub gateway_identify_payload: GatewayEvent<types::GatewayIdentifyPayload>,
pub gateway_resume: GatewayEvent<types::GatewayResume>,
}
#[derive(Default, Debug)]
pub struct Message {
pub create: GatewayEvent<MessageCreate>,
pub update: GatewayEvent<MessageUpdate>,
pub delete: GatewayEvent<MessageDelete>,
pub delete_bulk: GatewayEvent<MessageDeleteBulk>,
pub reaction_add: GatewayEvent<MessageReactionAdd>,
pub reaction_remove: GatewayEvent<MessageReactionRemove>,
pub reaction_remove_all: GatewayEvent<MessageReactionRemoveAll>,
pub reaction_remove_emoji: GatewayEvent<MessageReactionRemoveEmoji>,
pub create: GatewayEvent<types::MessageCreate>,
pub update: GatewayEvent<types::MessageUpdate>,
pub delete: GatewayEvent<types::MessageDelete>,
pub delete_bulk: GatewayEvent<types::MessageDeleteBulk>,
pub reaction_add: GatewayEvent<types::MessageReactionAdd>,
pub reaction_remove: GatewayEvent<types::MessageReactionRemove>,
pub reaction_remove_all: GatewayEvent<types::MessageReactionRemoveAll>,
pub reaction_remove_emoji: GatewayEvent<types::MessageReactionRemoveEmoji>,
}
#[derive(Default, Debug)]
pub struct User {
pub update: GatewayEvent<UserUpdate>,
pub presence_update: GatewayEvent<PresenceUpdate>,
pub typing_start_event: GatewayEvent<TypingStartEvent>,
pub update: GatewayEvent<types::UserUpdate>,
pub presence_update: GatewayEvent<types::PresenceUpdate>,
pub typing_start_event: GatewayEvent<types::TypingStartEvent>,
}
#[derive(Default, Debug)]
pub struct Channel {
pub create: GatewayEvent<ChannelCreate>,
pub update: GatewayEvent<ChannelUpdate>,
pub delete: GatewayEvent<ChannelDelete>,
pub pins_update: GatewayEvent<ChannelPinsUpdate>,
pub create: GatewayEvent<types::ChannelCreate>,
pub update: GatewayEvent<types::ChannelUpdate>,
pub delete: GatewayEvent<types::ChannelDelete>,
pub pins_update: GatewayEvent<types::ChannelPinsUpdate>,
}
#[derive(Default, Debug)]
pub struct Thread {
pub create: GatewayEvent<ThreadCreate>,
pub update: GatewayEvent<ThreadUpdate>,
pub delete: GatewayEvent<ThreadDelete>,
pub list_sync: GatewayEvent<ThreadListSync>,
pub member_update: GatewayEvent<ThreadMemberUpdate>,
pub members_update: GatewayEvent<ThreadMembersUpdate>,
pub create: GatewayEvent<types::ThreadCreate>,
pub update: GatewayEvent<types::ThreadUpdate>,
pub delete: GatewayEvent<types::ThreadDelete>,
pub list_sync: GatewayEvent<types::ThreadListSync>,
pub member_update: GatewayEvent<types::ThreadMemberUpdate>,
pub members_update: GatewayEvent<types::ThreadMembersUpdate>,
}
#[derive(Default, Debug)]
pub struct Guild {
pub create: GatewayEvent<GuildCreate>,
pub create: GatewayEvent<types::GuildCreate>,
/*pub update: GatewayEvent<ThreadCreate>,
pub delete: GatewayEvent<ThreadCreate>,
pub audit_log_entry_create: GatewayEvent<ThreadCreate>,
@ -837,21 +805,21 @@ mod example {
#[derive(Debug)]
struct Consumer;
impl Observer<GatewayResume> for Consumer {
fn update(&self, data: &GatewayResume) {
impl Observer<types::GatewayResume> for Consumer {
fn update(&self, data: &types::GatewayResume) {
println!("{}", data.token)
}
}
#[tokio::test]
async fn test_observer_behaviour() {
let mut event = GatewayEvent::new(GatewayResume {
let mut event = GatewayEvent::new(types::GatewayResume {
token: "start".to_string(),
session_id: "start".to_string(),
seq: "start".to_string(),
});
let new_data = GatewayResume {
let new_data = types::GatewayResume {
token: "token_3276ha37am3".to_string(),
session_id: "89346671230".to_string(),
seq: "3".to_string(),