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

Change `UserMeta` to `ChorusUser`

This commit is contained in:
bitfl0wer 2023-08-24 21:06:28 +02:00
parent 7d0db49e5c
commit fb7e33c0ec
18 changed files with 95 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/api/auth/login.rs
View File

@ -8,7 +8,7 @@ use serde_json::to_string;
use crate::api::LimitType; use crate::api::LimitType;
use crate::errors::ChorusResult; use crate::errors::ChorusResult;
use crate::gateway::Gateway; use crate::gateway::Gateway;
use crate::instance::{Instance, UserMeta}; use crate::instance::{ChorusUser, Instance};
use crate::ratelimiter::ChorusRequest; use crate::ratelimiter::ChorusRequest;
use crate::types::{GatewayIdentifyPayload, LoginResult, LoginSchema}; use crate::types::{GatewayIdentifyPayload, LoginResult, LoginSchema};
@ -17,7 +17,7 @@ impl Instance {
/// ///
/// # Reference /// # Reference
/// See <https://docs.spacebar.chat/routes/#post-/auth/login/> /// See <https://docs.spacebar.chat/routes/#post-/auth/login/>
pub async fn login_account(&mut self, login_schema: &LoginSchema) -> ChorusResult<UserMeta> { pub async fn login_account(&mut self, login_schema: &LoginSchema) -> ChorusResult<ChorusUser> {
let endpoint_url = self.urls.api.clone() + "/auth/login"; let endpoint_url = self.urls.api.clone() + "/auth/login";
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -30,7 +30,7 @@ impl Instance {
// request (since login is an instance wide limit), which is why we are just cloning the // request (since login is an instance wide limit), which is why we are just cloning the
// instances' limits to pass them on as user_rate_limits later. // instances' limits to pass them on as user_rate_limits later.
let mut shell = let mut shell =
UserMeta::shell(Rc::new(RefCell::new(self.clone())), "None".to_string()).await; ChorusUser::shell(Rc::new(RefCell::new(self.clone())), "None".to_string()).await;
let login_result = chorus_request let login_result = chorus_request
.deserialize_response::<LoginResult>(&mut shell) .deserialize_response::<LoginResult>(&mut shell)
.await?; .await?;
@ -42,7 +42,7 @@ impl Instance {
let gateway = Gateway::new(self.urls.wss.clone()).await.unwrap(); let gateway = Gateway::new(self.urls.wss.clone()).await.unwrap();
identify.token = login_result.token.clone(); identify.token = login_result.token.clone();
gateway.send_identify(identify).await; gateway.send_identify(identify).await;
let user = UserMeta::new( let user = ChorusUser::new(
Rc::new(RefCell::new(self.clone())), Rc::new(RefCell::new(self.clone())),
login_result.token, login_result.token,
self.clone_limits_if_some(), self.clone_limits_if_some(),

10
src/api/auth/register.rs
View File

@ -9,7 +9,7 @@ use crate::types::GatewayIdentifyPayload;
use crate::{ use crate::{
api::policies::instance::LimitType, api::policies::instance::LimitType,
errors::ChorusResult, errors::ChorusResult,
instance::{Instance, Token, UserMeta}, instance::{ChorusUser, Instance, Token},
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::RegisterSchema, types::RegisterSchema,
}; };
@ -22,7 +22,7 @@ impl Instance {
pub async fn register_account( pub async fn register_account(
&mut self, &mut self,
register_schema: &RegisterSchema, register_schema: &RegisterSchema,
) -> ChorusResult<UserMeta> { ) -> ChorusResult<ChorusUser> {
let endpoint_url = self.urls.api.clone() + "/auth/register"; let endpoint_url = self.urls.api.clone() + "/auth/register";
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -35,7 +35,7 @@ impl Instance {
// request (since register is an instance wide limit), which is why we are just cloning // request (since register is an instance wide limit), which is why we are just cloning
// the instances' limits to pass them on as user_rate_limits later. // the instances' limits to pass them on as user_rate_limits later.
let mut shell = let mut shell =
UserMeta::shell(Rc::new(RefCell::new(self.clone())), "None".to_string()).await; ChorusUser::shell(Rc::new(RefCell::new(self.clone())), "None".to_string()).await;
let token = chorus_request let token = chorus_request
.deserialize_response::<Token>(&mut shell) .deserialize_response::<Token>(&mut shell)
.await? .await?
@ -44,12 +44,12 @@ impl Instance {
self.limits_information.as_mut().unwrap().ratelimits = shell.limits.unwrap(); self.limits_information.as_mut().unwrap().ratelimits = shell.limits.unwrap();
} }
let user_object = self.get_user(token.clone(), None).await.unwrap(); let user_object = self.get_user(token.clone(), None).await.unwrap();
let settings = UserMeta::get_settings(&token, &self.urls.api.clone(), self).await?; let settings = ChorusUser::get_settings(&token, &self.urls.api.clone(), self).await?;
let mut identify = GatewayIdentifyPayload::common(); let mut identify = GatewayIdentifyPayload::common();
let gateway = Gateway::new(self.urls.wss.clone()).await.unwrap(); let gateway = Gateway::new(self.urls.wss.clone()).await.unwrap();
identify.token = token.clone(); identify.token = token.clone();
gateway.send_identify(identify).await; gateway.send_identify(identify).await;
let user = UserMeta::new( let user = ChorusUser::new(
Rc::new(RefCell::new(self.clone())), Rc::new(RefCell::new(self.clone())),
token.clone(), token.clone(),
self.clone_limits_if_some(), self.clone_limits_if_some(),

16
src/api/channels/channels.rs
View File

@ -5,7 +5,7 @@ use crate::types::{AddChannelRecipientSchema, ModifyChannelPositionsSchema};
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::{ChorusError, ChorusResult}, errors::{ChorusError, ChorusResult},
instance::UserMeta, instance::ChorusUser,
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::{Channel, ChannelModifySchema, GetChannelMessagesSchema, Message, Snowflake}, types::{Channel, ChannelModifySchema, GetChannelMessagesSchema, Message, Snowflake},
}; };
@ -15,7 +15,7 @@ impl Channel {
/// ///
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/channel#get-channel> /// See <https://discord-userdoccers.vercel.app/resources/channel#get-channel>
pub async fn get(user: &mut UserMeta, channel_id: Snowflake) -> ChorusResult<Channel> { pub async fn get(user: &mut ChorusUser, channel_id: Snowflake) -> ChorusResult<Channel> {
let url = user.belongs_to.borrow().urls.api.clone(); let url = user.belongs_to.borrow().urls.api.clone();
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -33,7 +33,7 @@ impl Channel {
/// ///
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/channel#delete-channel> /// See <https://discord-userdoccers.vercel.app/resources/channel#delete-channel>
pub async fn delete(self, user: &mut UserMeta) -> ChorusResult<()> { pub async fn delete(self, user: &mut ChorusUser) -> ChorusResult<()> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
.delete(format!( .delete(format!(
@ -64,7 +64,7 @@ impl Channel {
pub async fn modify( pub async fn modify(
&self, &self,
modify_data: ChannelModifySchema, modify_data: ChannelModifySchema,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Channel> { ) -> ChorusResult<Channel> {
let channel_id = self.id; let channel_id = self.id;
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
@ -94,7 +94,7 @@ impl Channel {
pub async fn messages( pub async fn messages(
range: GetChannelMessagesSchema, range: GetChannelMessagesSchema,
channel_id: Snowflake, channel_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> Result<Vec<Message>, ChorusError> { ) -> Result<Vec<Message>, ChorusError> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -120,7 +120,7 @@ impl Channel {
pub async fn add_channel_recipient( pub async fn add_channel_recipient(
&self, &self,
recipient_id: Snowflake, recipient_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
add_channel_recipient_schema: Option<AddChannelRecipientSchema>, add_channel_recipient_schema: Option<AddChannelRecipientSchema>,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let mut request = Client::new() let mut request = Client::new()
@ -150,7 +150,7 @@ impl Channel {
pub async fn remove_channel_recipient( pub async fn remove_channel_recipient(
&self, &self,
recipient_id: Snowflake, recipient_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let request = Client::new() let request = Client::new()
.delete(format!( .delete(format!(
@ -176,7 +176,7 @@ impl Channel {
pub async fn modify_positions( pub async fn modify_positions(
schema: Vec<ModifyChannelPositionsSchema>, schema: Vec<ModifyChannelPositionsSchema>,
guild_id: Snowflake, guild_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let request = Client::new() let request = Client::new()
.patch(format!( .patch(format!(

34
src/api/channels/messages.rs
View File

@ -5,7 +5,7 @@ use serde_json::{from_value, to_string, Value};
use crate::api::LimitType; use crate::api::LimitType;
use crate::errors::{ChorusError, ChorusResult}; use crate::errors::{ChorusError, ChorusResult};
use crate::instance::UserMeta; use crate::instance::ChorusUser;
use crate::ratelimiter::ChorusRequest; use crate::ratelimiter::ChorusRequest;
use crate::types::{ use crate::types::{
Channel, CreateGreetMessage, Message, MessageAck, MessageModifySchema, MessageSearchEndpoint, Channel, CreateGreetMessage, Message, MessageAck, MessageModifySchema, MessageSearchEndpoint,
@ -19,7 +19,7 @@ impl Message {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/message#create-message> /// See <https://discord-userdoccers.vercel.app/resources/message#create-message>
pub async fn send( pub async fn send(
user: &mut UserMeta, user: &mut ChorusUser,
channel_id: Snowflake, channel_id: Snowflake,
mut message: MessageSendSchema, mut message: MessageSendSchema,
) -> ChorusResult<Message> { ) -> ChorusResult<Message> {
@ -87,7 +87,7 @@ impl Message {
pub(crate) async fn search( pub(crate) async fn search(
endpoint: MessageSearchEndpoint, endpoint: MessageSearchEndpoint,
query: MessageSearchQuery, query: MessageSearchQuery,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Vec<Message>> { ) -> ChorusResult<Vec<Message>> {
let limit_type = match &endpoint { let limit_type = match &endpoint {
MessageSearchEndpoint::Channel(id) => LimitType::Channel(*id), MessageSearchEndpoint::Channel(id) => LimitType::Channel(*id),
@ -136,7 +136,7 @@ impl Message {
/// See: <https://discord-userdoccers.vercel.app/resources/message#get-pinned-messages> /// See: <https://discord-userdoccers.vercel.app/resources/message#get-pinned-messages>
pub async fn get_sticky( pub async fn get_sticky(
channel_id: Snowflake, channel_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Vec<Message>> { ) -> ChorusResult<Vec<Message>> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -162,7 +162,7 @@ impl Message {
pub async fn sticky( pub async fn sticky(
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -185,7 +185,7 @@ impl Message {
pub async fn unsticky( pub async fn unsticky(
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -209,7 +209,7 @@ impl Message {
pub async fn get( pub async fn get(
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Message> { ) -> ChorusResult<Message> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -232,7 +232,7 @@ impl Message {
pub async fn create_greet( pub async fn create_greet(
channel_id: Snowflake, channel_id: Snowflake,
schema: CreateGreetMessage, schema: CreateGreetMessage,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Message> { ) -> ChorusResult<Message> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -263,7 +263,7 @@ impl Message {
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
schema: MessageAck, schema: MessageAck,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Option<String>> { ) -> ChorusResult<Option<String>> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -292,7 +292,7 @@ impl Message {
pub async fn crosspost( pub async fn crosspost(
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Message> { ) -> ChorusResult<Message> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -316,7 +316,7 @@ impl Message {
pub async fn hide_from_guild_feed( pub async fn hide_from_guild_feed(
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -347,7 +347,7 @@ impl Message {
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
schema: MessageModifySchema, schema: MessageModifySchema,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Message> { ) -> ChorusResult<Message> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -370,7 +370,7 @@ impl Message {
pub async fn delete( pub async fn delete(
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -399,7 +399,7 @@ impl Message {
pub async fn bulk_delete( pub async fn bulk_delete(
channel_id: Snowflake, channel_id: Snowflake,
messages: Vec<Snowflake>, messages: Vec<Snowflake>,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
if messages.len() < 2 { if messages.len() < 2 {
return Err(ChorusError::InvalidArguments { return Err(ChorusError::InvalidArguments {
@ -427,7 +427,7 @@ impl Message {
/// See: <https://discord-userdoccers.vercel.app/resources/message#acknowledge-pinned-messages> /// See: <https://discord-userdoccers.vercel.app/resources/message#acknowledge-pinned-messages>
pub async fn acknowledge_pinned( pub async fn acknowledge_pinned(
channel_id: Snowflake, channel_id: Snowflake,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -453,7 +453,7 @@ fn search_error(result_text: String) -> ChorusError {
} }
} }
impl UserMeta { impl ChorusUser {
/// Sends a message in the channel with the provided channel_id. /// Sends a message in the channel with the provided channel_id.
/// Returns the sent message. /// Returns the sent message.
/// ///
@ -485,7 +485,7 @@ impl Channel {
pub async fn search_messages( pub async fn search_messages(
channel_id: Snowflake, channel_id: Snowflake,
query: MessageSearchQuery, query: MessageSearchQuery,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Vec<Message>> { ) -> ChorusResult<Vec<Message>> {
Message::search(MessageSearchEndpoint::Channel(channel_id), query, user).await Message::search(MessageSearchEndpoint::Channel(channel_id), query, user).await
} }

6
src/api/channels/permissions.rs
View File

@ -4,7 +4,7 @@ use serde_json::to_string;
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::{ChorusError, ChorusResult}, errors::{ChorusError, ChorusResult},
instance::UserMeta, instance::ChorusUser,
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::{self, PermissionOverwrite, Snowflake}, types::{self, PermissionOverwrite, Snowflake},
}; };
@ -21,7 +21,7 @@ impl types::Channel {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/channel#modify-channel-permissions> /// See <https://discord-userdoccers.vercel.app/resources/channel#modify-channel-permissions>
pub async fn edit_permissions( pub async fn edit_permissions(
user: &mut UserMeta, user: &mut ChorusUser,
channel_id: Snowflake, channel_id: Snowflake,
overwrite: PermissionOverwrite, overwrite: PermissionOverwrite,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
@ -59,7 +59,7 @@ impl types::Channel {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/channel#delete-channel-permission> /// See <https://discord-userdoccers.vercel.app/resources/channel#delete-channel-permission>
pub async fn delete_permission( pub async fn delete_permission(
user: &mut UserMeta, user: &mut ChorusUser,
channel_id: Snowflake, channel_id: Snowflake,
overwrite_id: Snowflake, overwrite_id: Snowflake,
) -> ChorusResult<()> { ) -> ChorusResult<()> {

14
src/api/channels/reactions.rs
View File

@ -3,7 +3,7 @@ use reqwest::Client;
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::ChorusResult, errors::ChorusResult,
instance::UserMeta, instance::ChorusUser,
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::{self, PublicUser, Snowflake}, types::{self, PublicUser, Snowflake},
}; };
@ -21,7 +21,7 @@ impl ReactionMeta {
/// ///
/// # Reference /// # Reference
/// See <https://discord.com/developers/docs/resources/channel#delete-all-reactions> /// See <https://discord.com/developers/docs/resources/channel#delete-all-reactions>
pub async fn delete_all(&self, user: &mut UserMeta) -> ChorusResult<()> { pub async fn delete_all(&self, user: &mut ChorusUser) -> ChorusResult<()> {
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions", "{}/channels/{}/messages/{}/reactions",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
@ -44,7 +44,7 @@ impl ReactionMeta {
/// ///
/// # Reference /// # Reference
/// See <https://discord.com/developers/docs/resources/channel#get-reactions> /// See <https://discord.com/developers/docs/resources/channel#get-reactions>
pub async fn get(&self, emoji: &str, user: &mut UserMeta) -> ChorusResult<Vec<PublicUser>> { pub async fn get(&self, emoji: &str, user: &mut ChorusUser) -> ChorusResult<Vec<PublicUser>> {
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}", "{}/channels/{}/messages/{}/reactions/{}",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
@ -70,7 +70,7 @@ impl ReactionMeta {
/// ///
/// # Reference /// # Reference
/// See <https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji> /// See <https://discord.com/developers/docs/resources/channel#delete-all-reactions-for-emoji>
pub async fn delete_emoji(&self, emoji: &str, user: &mut UserMeta) -> ChorusResult<()> { pub async fn delete_emoji(&self, emoji: &str, user: &mut ChorusUser) -> ChorusResult<()> {
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}", "{}/channels/{}/messages/{}/reactions/{}",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
@ -99,7 +99,7 @@ impl ReactionMeta {
/// ///
/// # Reference /// # Reference
/// See <https://discord.com/developers/docs/resources/channel#create-reaction> /// See <https://discord.com/developers/docs/resources/channel#create-reaction>
pub async fn create(&self, emoji: &str, user: &mut UserMeta) -> ChorusResult<()> { pub async fn create(&self, emoji: &str, user: &mut ChorusUser) -> ChorusResult<()> {
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/@me", "{}/channels/{}/messages/{}/reactions/{}/@me",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
@ -124,7 +124,7 @@ impl ReactionMeta {
/// ///
/// # Reference /// # Reference
/// See <https://discord.com/developers/docs/resources/channel#delete-own-reaction> /// See <https://discord.com/developers/docs/resources/channel#delete-own-reaction>
pub async fn remove(&self, emoji: &str, user: &mut UserMeta) -> ChorusResult<()> { pub async fn remove(&self, emoji: &str, user: &mut ChorusUser) -> ChorusResult<()> {
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/@me", "{}/channels/{}/messages/{}/reactions/{}/@me",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
@ -154,7 +154,7 @@ impl ReactionMeta {
&self, &self,
user_id: Snowflake, user_id: Snowflake,
emoji: &str, emoji: &str,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/{}", "{}/channels/{}/messages/{}/reactions/{}/{}",

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

@ -5,7 +5,7 @@ use serde_json::to_string;
use crate::api::LimitType; use crate::api::LimitType;
use crate::errors::ChorusError; use crate::errors::ChorusError;
use crate::errors::ChorusResult; use crate::errors::ChorusResult;
use crate::instance::UserMeta; use crate::instance::ChorusUser;
use crate::ratelimiter::ChorusRequest; use crate::ratelimiter::ChorusRequest;
use crate::types::{ use crate::types::{
Channel, ChannelCreateSchema, Guild, GuildBanCreateSchema, GuildCreateSchema, GuildModifySchema, Channel, ChannelCreateSchema, Guild, GuildBanCreateSchema, GuildCreateSchema, GuildModifySchema,
@ -18,7 +18,7 @@ impl Guild {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#create-guild> /// See <https://discord-userdoccers.vercel.app/resources/guild#create-guild>
pub async fn create( pub async fn create(
user: &mut UserMeta, user: &mut ChorusUser,
guild_create_schema: GuildCreateSchema, guild_create_schema: GuildCreateSchema,
) -> ChorusResult<Guild> { ) -> ChorusResult<Guild> {
let url = format!("{}/guilds", user.belongs_to.borrow().urls.api); let url = format!("{}/guilds", user.belongs_to.borrow().urls.api);
@ -52,7 +52,7 @@ impl Guild {
/// ///
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#delete-guild> /// See <https://discord-userdoccers.vercel.app/resources/guild#delete-guild>
pub async fn delete(user: &mut UserMeta, guild_id: Snowflake) -> ChorusResult<()> { pub async fn delete(user: &mut ChorusUser, guild_id: Snowflake) -> ChorusResult<()> {
let url = format!( let url = format!(
"{}/guilds/{}/delete", "{}/guilds/{}/delete",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
@ -79,7 +79,7 @@ impl Guild {
/// See <https://discord-userdoccers.vercel.app/resources/channel#create-guild-channel> /// See <https://discord-userdoccers.vercel.app/resources/channel#create-guild-channel>
pub async fn create_channel( pub async fn create_channel(
&self, &self,
user: &mut UserMeta, user: &mut ChorusUser,
schema: ChannelCreateSchema, schema: ChannelCreateSchema,
) -> ChorusResult<Channel> { ) -> ChorusResult<Channel> {
Channel::create(user, self.id, schema).await Channel::create(user, self.id, schema).await
@ -91,7 +91,7 @@ impl Guild {
/// ///
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/channel#get-guild-channels> /// See <https://discord-userdoccers.vercel.app/resources/channel#get-guild-channels>
pub async fn channels(&self, user: &mut UserMeta) -> ChorusResult<Vec<Channel>> { pub async fn channels(&self, user: &mut ChorusUser) -> ChorusResult<Vec<Channel>> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
.get(format!( .get(format!(
@ -125,7 +125,7 @@ impl Guild {
/// ///
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#get-guild> /// See <https://discord-userdoccers.vercel.app/resources/guild#get-guild>
pub async fn get(guild_id: Snowflake, user: &mut UserMeta) -> ChorusResult<Guild> { pub async fn get(guild_id: Snowflake, user: &mut ChorusUser) -> ChorusResult<Guild> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
.get(format!( .get(format!(
@ -144,7 +144,7 @@ impl Guild {
guild_id: Snowflake, guild_id: Snowflake,
user_id: Snowflake, user_id: Snowflake,
schema: GuildBanCreateSchema, schema: GuildBanCreateSchema,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<GuildBan> { ) -> ChorusResult<GuildBan> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -169,7 +169,7 @@ impl Guild {
pub async fn modify( pub async fn modify(
guild_id: Snowflake, guild_id: Snowflake,
schema: GuildModifySchema, schema: GuildModifySchema,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Guild> { ) -> ChorusResult<Guild> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request: Client::new() request: Client::new()
@ -195,7 +195,7 @@ impl Channel {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/channel#create-guild-channel> /// See <https://discord-userdoccers.vercel.app/resources/channel#create-guild-channel>
pub async fn create( pub async fn create(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
schema: ChannelCreateSchema, schema: ChannelCreateSchema,
) -> ChorusResult<Channel> { ) -> ChorusResult<Channel> {

8
src/api/guilds/member.rs
View File

@ -3,7 +3,7 @@ use reqwest::Client;
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::ChorusResult, errors::ChorusResult,
instance::UserMeta, instance::ChorusUser,
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::{self, GuildMember, Snowflake}, types::{self, GuildMember, Snowflake},
}; };
@ -14,7 +14,7 @@ impl types::GuildMember {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#get-guild-member> /// See <https://discord-userdoccers.vercel.app/resources/guild#get-guild-member>
pub async fn get( pub async fn get(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
member_id: Snowflake, member_id: Snowflake,
) -> ChorusResult<GuildMember> { ) -> ChorusResult<GuildMember> {
@ -40,7 +40,7 @@ impl types::GuildMember {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#add-guild-member-role> /// See <https://discord-userdoccers.vercel.app/resources/guild#add-guild-member-role>
pub async fn add_role( pub async fn add_role(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
member_id: Snowflake, member_id: Snowflake,
role_id: Snowflake, role_id: Snowflake,
@ -69,7 +69,7 @@ impl types::GuildMember {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#remove-guild-member-role> /// See <https://discord-userdoccers.vercel.app/resources/guild#remove-guild-member-role>
pub async fn remove_role( pub async fn remove_role(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
member_id: Snowflake, member_id: Snowflake,
role_id: Snowflake, role_id: Snowflake,

4
src/api/guilds/messages.rs
View File

@ -1,5 +1,5 @@
use crate::errors::ChorusResult; use crate::errors::ChorusResult;
use crate::instance::UserMeta; use crate::instance::ChorusUser;
use crate::types::{Guild, Message, MessageSearchQuery, Snowflake}; use crate::types::{Guild, Message, MessageSearchQuery, Snowflake};
impl Guild { impl Guild {
@ -16,7 +16,7 @@ impl Guild {
pub async fn search_messages( pub async fn search_messages(
guild_id: Snowflake, guild_id: Snowflake,
query: MessageSearchQuery, query: MessageSearchQuery,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<Vec<Message>> { ) -> ChorusResult<Vec<Message>> {
Message::search( Message::search(
crate::types::MessageSearchEndpoint::GuildChannel(guild_id), crate::types::MessageSearchEndpoint::GuildChannel(guild_id),

12
src/api/guilds/roles.rs
View File

@ -4,7 +4,7 @@ use serde_json::to_string;
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::{ChorusError, ChorusResult}, errors::{ChorusError, ChorusResult},
instance::UserMeta, instance::ChorusUser,
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::{self, RoleCreateModifySchema, RoleObject, RolePositionUpdateSchema, Snowflake}, types::{self, RoleCreateModifySchema, RoleObject, RolePositionUpdateSchema, Snowflake},
}; };
@ -15,7 +15,7 @@ impl types::RoleObject {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#get-guild-roles> /// See <https://discord-userdoccers.vercel.app/resources/guild#get-guild-roles>
pub async fn get_all( pub async fn get_all(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
) -> ChorusResult<Vec<RoleObject>> { ) -> ChorusResult<Vec<RoleObject>> {
let url = format!( let url = format!(
@ -39,7 +39,7 @@ impl types::RoleObject {
/// # Reference /// # Reference
/// See <https://docs.spacebar.chat/routes/#get-/guilds/-guild_id-/roles/-role_id-/> /// See <https://docs.spacebar.chat/routes/#get-/guilds/-guild_id-/roles/-role_id-/>
pub async fn get( pub async fn get(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
role_id: Snowflake, role_id: Snowflake,
) -> ChorusResult<RoleObject> { ) -> ChorusResult<RoleObject> {
@ -65,7 +65,7 @@ impl types::RoleObject {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#create-guild-role> /// See <https://discord-userdoccers.vercel.app/resources/guild#create-guild-role>
pub async fn create( pub async fn create(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
role_create_schema: RoleCreateModifySchema, role_create_schema: RoleCreateModifySchema,
) -> ChorusResult<RoleObject> { ) -> ChorusResult<RoleObject> {
@ -99,7 +99,7 @@ impl types::RoleObject {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#modify-guild-role-positions> /// See <https://discord-userdoccers.vercel.app/resources/guild#modify-guild-role-positions>
pub async fn position_update( pub async fn position_update(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
role_position_update_schema: RolePositionUpdateSchema, role_position_update_schema: RolePositionUpdateSchema,
) -> ChorusResult<RoleObject> { ) -> ChorusResult<RoleObject> {
@ -132,7 +132,7 @@ impl types::RoleObject {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/guild#modify-guild-role> /// See <https://discord-userdoccers.vercel.app/resources/guild#modify-guild-role>
pub async fn modify( pub async fn modify(
user: &mut UserMeta, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
role_id: Snowflake, role_id: Snowflake,
role_create_schema: RoleCreateModifySchema, role_create_schema: RoleCreateModifySchema,

4
src/api/invites/mod.rs
View File

@ -2,11 +2,11 @@ use reqwest::Client;
use serde_json::to_string; use serde_json::to_string;
use crate::errors::ChorusResult; use crate::errors::ChorusResult;
use crate::instance::UserMeta; use crate::instance::ChorusUser;
use crate::ratelimiter::ChorusRequest; use crate::ratelimiter::ChorusRequest;
use crate::types::{CreateChannelInviteSchema, GuildInvite, Invite, Snowflake}; use crate::types::{CreateChannelInviteSchema, GuildInvite, Invite, Snowflake};
impl UserMeta { impl ChorusUser {
/// Accepts an invite to a guild, group DM, or DM. /// Accepts an invite to a guild, group DM, or DM.
/// ///
/// Note that the session ID is required for guest invites. /// Note that the session ID is required for guest invites.

4
src/api/users/channels.rs
View File

@ -4,12 +4,12 @@ use serde_json::to_string;
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::ChorusResult, errors::ChorusResult,
instance::UserMeta, instance::ChorusUser,
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::{Channel, PrivateChannelCreateSchema}, types::{Channel, PrivateChannelCreateSchema},
}; };
impl UserMeta { impl ChorusUser {
/// Creates a DM channel or group DM channel. /// Creates a DM channel or group DM channel.
/// ///
/// One recipient creates or returns an existing DM channel, /// One recipient creates or returns an existing DM channel,

4
src/api/users/guilds.rs
View File

@ -2,11 +2,11 @@ use reqwest::Client;
use serde_json::to_string; use serde_json::to_string;
use crate::errors::ChorusResult; use crate::errors::ChorusResult;
use crate::instance::UserMeta; use crate::instance::ChorusUser;
use crate::ratelimiter::ChorusRequest; use crate::ratelimiter::ChorusRequest;
use crate::types::Snowflake; use crate::types::Snowflake;
impl UserMeta { impl ChorusUser {
/// Leaves a given guild. /// Leaves a given guild.
/// ///
/// # Reference: /// # Reference:

4
src/api/users/relationships.rs
View File

@ -4,14 +4,14 @@ use serde_json::to_string;
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::ChorusResult, errors::ChorusResult,
instance::UserMeta, instance::ChorusUser,
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::{ types::{
self, CreateUserRelationshipSchema, FriendRequestSendSchema, RelationshipType, Snowflake, self, CreateUserRelationshipSchema, FriendRequestSendSchema, RelationshipType, Snowflake,
}, },
}; };
impl UserMeta { impl ChorusUser {
/// Retrieves a list of mutual friends between the authenticated user and a given user. /// Retrieves a list of mutual friends between the authenticated user and a given user.
/// ///
/// # Reference /// # Reference

10
src/api/users/users.rs
View File

@ -6,12 +6,12 @@ use serde_json::to_string;
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::{ChorusError, ChorusResult}, errors::{ChorusError, ChorusResult},
instance::{Instance, UserMeta}, instance::{ChorusUser, Instance},
ratelimiter::ChorusRequest, ratelimiter::ChorusRequest,
types::{User, UserModifySchema, UserSettings}, types::{User, UserModifySchema, UserSettings},
}; };
impl UserMeta { impl ChorusUser {
/// Gets a user by id, or if the id is None, gets the current user. /// Gets a user by id, or if the id is None, gets the current user.
/// ///
/// # Notes /// # Notes
@ -85,7 +85,7 @@ impl User {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/user#get-user> and /// See <https://discord-userdoccers.vercel.app/resources/user#get-user> and
/// <https://discord-userdoccers.vercel.app/resources/user#get-current-user> /// <https://discord-userdoccers.vercel.app/resources/user#get-current-user>
pub async fn get(user: &mut UserMeta, id: Option<&String>) -> ChorusResult<User> { pub async fn get(user: &mut ChorusUser, id: Option<&String>) -> ChorusResult<User> {
let url_api = user.belongs_to.borrow().urls.api.clone(); let url_api = user.belongs_to.borrow().urls.api.clone();
let url = if id.is_none() { let url = if id.is_none() {
format!("{}/users/@me", url_api) format!("{}/users/@me", url_api)
@ -121,7 +121,7 @@ impl User {
.get(format!("{}/users/@me/settings", url_api)) .get(format!("{}/users/@me/settings", url_api))
.header("Authorization", token); .header("Authorization", token);
let mut user = let mut user =
UserMeta::shell(Rc::new(RefCell::new(instance.clone())), token.clone()).await; ChorusUser::shell(Rc::new(RefCell::new(instance.clone())), token.clone()).await;
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest {
request, request,
limit_type: LimitType::Global, limit_type: LimitType::Global,
@ -148,7 +148,7 @@ impl Instance {
/// See <https://discord-userdoccers.vercel.app/resources/user#get-user> and /// See <https://discord-userdoccers.vercel.app/resources/user#get-user> and
/// <https://discord-userdoccers.vercel.app/resources/user#get-current-user> /// <https://discord-userdoccers.vercel.app/resources/user#get-current-user>
pub async fn get_user(&mut self, token: String, id: Option<&String>) -> ChorusResult<User> { pub async fn get_user(&mut self, token: String, id: Option<&String>) -> ChorusResult<User> {
let mut user = UserMeta::shell(Rc::new(RefCell::new(self.clone())), token).await; let mut user = ChorusUser::shell(Rc::new(RefCell::new(self.clone())), token).await;
let result = User::get(&mut user, id).await; let result = User::get(&mut user, id).await;
if self.limits_information.is_some() { if self.limits_information.is_some() {
self.limits_information.as_mut().unwrap().ratelimits = self.limits_information.as_mut().unwrap().ratelimits =

12
src/instance.rs
View File

@ -87,7 +87,7 @@ impl fmt::Display for Token {
/// A UserMeta is a representation of an authenticated user on an [Instance]. /// A UserMeta is a representation of an authenticated user on an [Instance].
/// It is used for most authenticated actions on a Spacebar server. /// It is used for most authenticated actions on a Spacebar server.
/// It also has its own [Gateway] connection. /// It also has its own [Gateway] connection.
pub struct UserMeta { pub struct ChorusUser {
pub belongs_to: Rc<RefCell<Instance>>, pub belongs_to: Rc<RefCell<Instance>>,
pub token: String, pub token: String,
pub limits: Option<HashMap<LimitType, Limit>>, pub limits: Option<HashMap<LimitType, Limit>>,
@ -96,7 +96,7 @@ pub struct UserMeta {
pub gateway: GatewayHandle, pub gateway: GatewayHandle,
} }
impl UserMeta { impl ChorusUser {
pub fn token(&self) -> String { pub fn token(&self) -> String {
self.token.clone() self.token.clone()
} }
@ -117,8 +117,8 @@ impl UserMeta {
settings: Arc<RwLock<UserSettings>>, settings: Arc<RwLock<UserSettings>>,
object: Arc<RwLock<User>>, object: Arc<RwLock<User>>,
gateway: GatewayHandle, gateway: GatewayHandle,
) -> UserMeta { ) -> ChorusUser {
UserMeta { ChorusUser {
belongs_to, belongs_to,
token, token,
limits, limits,
@ -133,13 +133,13 @@ impl UserMeta {
/// registering or logging in to the Instance, where you do not yet have a User object, but still /// registering or logging in to the Instance, where you do not yet have a User object, but still
/// need to make a RateLimited request. To use the [`GatewayHandle`], you will have to identify /// need to make a RateLimited request. To use the [`GatewayHandle`], you will have to identify
/// first. /// first.
pub(crate) async fn shell(instance: Rc<RefCell<Instance>>, token: String) -> UserMeta { pub(crate) async fn shell(instance: Rc<RefCell<Instance>>, token: String) -> ChorusUser {
let settings = Arc::new(RwLock::new(UserSettings::default())); let settings = Arc::new(RwLock::new(UserSettings::default()));
let object = Arc::new(RwLock::new(User::default())); let object = Arc::new(RwLock::new(User::default()));
let wss_url = instance.borrow().urls.wss.clone(); let wss_url = instance.borrow().urls.wss.clone();
// Dummy gateway object // Dummy gateway object
let gateway = Gateway::new(wss_url).await.unwrap(); let gateway = Gateway::new(wss_url).await.unwrap();
UserMeta { ChorusUser {
token, token,
belongs_to: instance.clone(), belongs_to: instance.clone(),
limits: instance limits: instance

12
src/ratelimiter.rs
View File

@ -8,7 +8,7 @@ use serde_json::from_str;
use crate::{ use crate::{
api::{Limit, LimitType}, api::{Limit, LimitType},
errors::{ChorusError, ChorusResult}, errors::{ChorusError, ChorusResult},
instance::UserMeta, instance::ChorusUser,
types::{types::subconfigs::limits::rates::RateLimits, LimitsConfiguration}, types::{types::subconfigs::limits::rates::RateLimits, LimitsConfiguration},
}; };
@ -24,7 +24,7 @@ impl ChorusRequest {
/// If the user is not rate limited and the instance has rate limits enabled, it will update the /// If the user is not rate limited and the instance has rate limits enabled, it will update the
/// rate limits. /// rate limits.
#[allow(clippy::await_holding_refcell_ref)] #[allow(clippy::await_holding_refcell_ref)]
pub(crate) async fn send_request(self, user: &mut UserMeta) -> ChorusResult<Response> { pub(crate) async fn send_request(self, user: &mut ChorusUser) -> ChorusResult<Response> {
if !ChorusRequest::can_send_request(user, &self.limit_type) { if !ChorusRequest::can_send_request(user, &self.limit_type) {
log::info!("Rate limit hit. Bucket: {:?}", self.limit_type); log::info!("Rate limit hit. Bucket: {:?}", self.limit_type);
return Err(ChorusError::RateLimited { return Err(ChorusError::RateLimited {
@ -73,7 +73,7 @@ impl ChorusRequest {
Ok(result) Ok(result)
} }
fn can_send_request(user: &mut UserMeta, limit_type: &LimitType) -> bool { fn can_send_request(user: &mut ChorusUser, limit_type: &LimitType) -> bool {
log::trace!("Checking if user or instance is rate-limited..."); log::trace!("Checking if user or instance is rate-limited...");
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
if belongs_to.limits_information.is_none() { if belongs_to.limits_information.is_none() {
@ -236,7 +236,7 @@ impl ChorusRequest {
/// set to the current unix timestamp + the rate limit window. The remaining rate limit is /// set to the current unix timestamp + the rate limit window. The remaining rate limit is
/// reset to the rate limit limit. /// reset to the rate limit limit.
/// 2. The remaining rate limit is decreased by 1. /// 2. The remaining rate limit is decreased by 1.
fn update_rate_limits(user: &mut UserMeta, limit_type: &LimitType, response_was_err: bool) { fn update_rate_limits(user: &mut ChorusUser, limit_type: &LimitType, response_was_err: bool) {
if user.belongs_to.borrow().limits_information.is_none() { if user.belongs_to.borrow().limits_information.is_none() {
return; return;
} }
@ -429,7 +429,7 @@ impl ChorusRequest {
/// Sends a [`ChorusRequest`] and returns a [`ChorusResult`] that contains nothing if the request /// Sends a [`ChorusRequest`] and returns a [`ChorusResult`] that contains nothing if the request
/// was successful, or a [`ChorusError`] if the request failed. /// was successful, or a [`ChorusError`] if the request failed.
pub(crate) async fn handle_request_as_result(self, user: &mut UserMeta) -> ChorusResult<()> { pub(crate) async fn handle_request_as_result(self, user: &mut ChorusUser) -> ChorusResult<()> {
match self.send_request(user).await { match self.send_request(user).await {
Ok(_) => Ok(()), Ok(_) => Ok(()),
Err(e) => Err(e), Err(e) => Err(e),
@ -440,7 +440,7 @@ impl ChorusRequest {
/// was successful, or a [`ChorusError`] if the request failed. /// was successful, or a [`ChorusError`] if the request failed.
pub(crate) async fn deserialize_response<T: for<'a> Deserialize<'a>>( pub(crate) async fn deserialize_response<T: for<'a> Deserialize<'a>>(
self, self,
user: &mut UserMeta, user: &mut ChorusUser,
) -> ChorusResult<T> { ) -> ChorusResult<T> {
let response = self.send_request(user).await?; let response = self.send_request(user).await?;
debug!("Got response: {:?}", response); debug!("Got response: {:?}", response);

10
tests/common/mod.rs
View File

@ -2,7 +2,7 @@ use std::sync::{Arc, RwLock};
use chorus::gateway::Gateway; use chorus::gateway::Gateway;
use chorus::{ use chorus::{
instance::{Instance, UserMeta}, instance::{ChorusUser, Instance},
types::{ types::{
Channel, ChannelCreateSchema, Guild, GuildCreateSchema, RegisterSchema, Channel, ChannelCreateSchema, Guild, GuildCreateSchema, RegisterSchema,
RoleCreateModifySchema, RoleObject, RoleCreateModifySchema, RoleObject,
@ -14,7 +14,7 @@ use chorus::{
#[derive(Debug)] #[derive(Debug)]
pub(crate) struct TestBundle { pub(crate) struct TestBundle {
pub urls: UrlBundle, pub urls: UrlBundle,
pub user: UserMeta, pub user: ChorusUser,
pub instance: Instance, pub instance: Instance,
pub guild: Arc<RwLock<Guild>>, pub guild: Arc<RwLock<Guild>>,
pub role: Arc<RwLock<RoleObject>>, pub role: Arc<RwLock<RoleObject>>,
@ -23,7 +23,7 @@ pub(crate) struct TestBundle {
#[allow(unused)] #[allow(unused)]
impl TestBundle { impl TestBundle {
pub(crate) async fn create_user(&mut self, username: &str) -> UserMeta { pub(crate) async fn create_user(&mut self, username: &str) -> ChorusUser {
let register_schema = RegisterSchema { let register_schema = RegisterSchema {
username: username.to_string(), username: username.to_string(),
consent: true, consent: true,
@ -35,8 +35,8 @@ impl TestBundle {
.await .await
.unwrap() .unwrap()
} }
pub(crate) async fn clone_user_without_gateway(&self) -> UserMeta { pub(crate) async fn clone_user_without_gateway(&self) -> ChorusUser {
UserMeta { ChorusUser {
belongs_to: self.user.belongs_to.clone(), belongs_to: self.user.belongs_to.clone(),
token: self.user.token.clone(), token: self.user.token.clone(),
limits: self.user.limits.clone(), limits: self.user.limits.clone(),