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

Rebase

This commit is contained in:
kozabrada123 2023-06-09 18:14:20 +02:00
parent cd52c5ac3a 05252d55b2
commit 10617ca85c
17 changed files with 371 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6,7 +6,7 @@ pub mod login {
use serde_json::{from_str, json}; use serde_json::{from_str, json};
use crate::api::limits::LimitType; use crate::api::limits::LimitType;
use crate::errors::InstanceServerError; use crate::errors::ChorusLibError;
use crate::instance::{Instance, UserMeta}; use crate::instance::{Instance, UserMeta};
use crate::limit::LimitedRequester; use crate::limit::LimitedRequester;
use crate::types::{ErrorResponse, LoginResult, LoginSchema}; use crate::types::{ErrorResponse, LoginResult, LoginSchema};
@ -15,7 +15,7 @@ pub mod login {
pub async fn login_account( pub async fn login_account(
&mut self, &mut self,
login_schema: &LoginSchema, login_schema: &LoginSchema,
) -> Result<UserMeta, InstanceServerError> { ) -> Result<UserMeta, ChorusLibError> {
let mut requester = LimitedRequester::new().await; let mut requester = LimitedRequester::new().await;
let json_schema = json!(login_schema); let json_schema = json!(login_schema);
let client = Client::new(); let client = Client::new();
@ -34,7 +34,7 @@ pub mod login {
) )
.await; .await;
if response.is_err() { if response.is_err() {
return Err(InstanceServerError::NoResponse); return Err(ChorusLibError::NoResponse);
} }
let response_unwrap = response.unwrap(); let response_unwrap = response.unwrap();
@ -49,7 +49,7 @@ pub mod login {
error += &(error_item.message.to_string() + " (" + &error_item.code + ")"); error += &(error_item.message.to_string() + " (" + &error_item.code + ")");
} }
} }
return Err(InstanceServerError::InvalidFormBodyError { error_type, error }); return Err(ChorusLibError::InvalidFormBodyError { error_type, error });
} }
let cloned_limits = self.limits.clone(); let cloned_limits = self.limits.clone();

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

@ -6,7 +6,7 @@ pub mod register {
use crate::{ use crate::{
api::limits::LimitType, api::limits::LimitType,
errors::InstanceServerError, errors::ChorusLibError,
instance::{Instance, Token, UserMeta}, instance::{Instance, Token, UserMeta},
limit::LimitedRequester, limit::LimitedRequester,
types::{ErrorResponse, RegisterSchema}, types::{ErrorResponse, RegisterSchema},
@ -18,12 +18,12 @@ pub mod register {
# Arguments # Arguments
* `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user. * `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user.
# Errors # Errors
* [`InstanceServerError`] - If the server does not respond. * [`ChorusLibError`] - If the server does not respond.
*/ */
pub async fn register_account( pub async fn register_account(
&mut self, &mut self,
register_schema: &RegisterSchema, register_schema: &RegisterSchema,
) -> Result<UserMeta, InstanceServerError> { ) -> Result<UserMeta, ChorusLibError> {
let json_schema = json!(register_schema); let json_schema = json!(register_schema);
let mut limited_requester = LimitedRequester::new().await; let mut limited_requester = LimitedRequester::new().await;
let client = Client::new(); let client = Client::new();
@ -42,7 +42,7 @@ pub mod register {
) )
.await; .await;
if response.is_err() { if response.is_err() {
return Err(InstanceServerError::NoResponse); return Err(ChorusLibError::NoResponse);
} }
let response_unwrap = response.unwrap(); let response_unwrap = response.unwrap();
@ -59,7 +59,7 @@ pub mod register {
error += &(error_item.message.to_string() + " (" + &error_item.code + ")"); error += &(error_item.message.to_string() + " (" + &error_item.code + ")");
} }
} }
return Err(InstanceServerError::InvalidFormBodyError { error_type, error }); return Err(ChorusLibError::InvalidFormBodyError { error_type, error });
} }
let user_object = self.get_user(token.clone(), None).await.unwrap(); let user_object = self.get_user(token.clone(), None).await.unwrap();
let settings = let settings =

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

@ -2,18 +2,14 @@ use reqwest::Client;
use serde_json::{from_str, to_string}; use serde_json::{from_str, to_string};
use crate::{ use crate::{
api::limits::Limits, errors::ChorusLibError,
errors::InstanceServerError,
instance::UserMeta, instance::UserMeta,
limit::LimitedRequester, limit::LimitedRequester,
types::{Channel, ChannelModifySchema}, types::{Channel, ChannelModifySchema},
}; };
impl Channel { impl Channel {
pub async fn get( pub async fn get(user: &mut UserMeta, channel_id: &str) -> Result<Channel, ChorusLibError> {
user: &mut UserMeta,
channel_id: &str,
) -> Result<Channel, InstanceServerError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let request = Client::new() let request = Client::new()
.get(format!( .get(format!(
@ -38,7 +34,7 @@ impl Channel {
let result_text = result.text().await.unwrap(); let result_text = result.text().await.unwrap();
match from_str::<Channel>(&result_text) { match from_str::<Channel>(&result_text) {
Ok(object) => Ok(object), Ok(object) => Ok(object),
Err(e) => Err(InstanceServerError::RequestErrorError { Err(e) => Err(ChorusLibError::RequestErrorError {
url: format!("{}/channels/{}/", belongs_to.urls.get_api(), channel_id), url: format!("{}/channels/{}/", belongs_to.urls.get_api(), channel_id),
error: e.to_string(), error: e.to_string(),
}), }),
@ -57,8 +53,8 @@ impl Channel {
/// ///
/// # Returns /// # Returns
/// ///
/// An `Option` that contains an `InstanceServerError` if an error occurred during the request, or `None` if the request was successful. /// An `Option` that contains an `ChorusLibError` if an error occurred during the request, or `None` if the request was successful.
pub async fn delete(self, user: &mut UserMeta) -> Option<InstanceServerError> { pub async fn delete(self, user: &mut UserMeta) -> Option<ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let request = Client::new() let request = Client::new()
.delete(format!( .delete(format!(
@ -95,12 +91,12 @@ impl Channel {
/// ///
/// # Returns /// # Returns
/// ///
/// A `Result` that contains a `Channel` object if the request was successful, or an `InstanceServerError` if an error occurred during the request. /// A `Result` that contains a `Channel` object if the request was successful, or an `ChorusLibError` if an error occurred during the request.
pub async fn modify( pub async fn modify(
modify_data: ChannelModifySchema, modify_data: ChannelModifySchema,
channel_id: &str, channel_id: &str,
user: &mut UserMeta, user: &mut UserMeta,
) -> Result<Channel, InstanceServerError> { ) -> Result<Channel, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let request = Client::new() let request = Client::new()
.patch(format!( .patch(format!(

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

@ -17,14 +17,14 @@ impl Message {
* `limits_instance` - The [`Limits`] of the instance. * `limits_instance` - The [`Limits`] of the instance.
* `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server. * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server.
# Errors # Errors
* [`InstanceServerError`] - If the message cannot be sent. * [`ChorusLibError`] - If the message cannot be sent.
*/ */
pub async fn send( pub async fn send(
user: &mut UserMeta, user: &mut UserMeta,
channel_id: String, channel_id: String,
message: &mut MessageSendSchema, message: &mut MessageSendSchema,
files: Option<Vec<PartialDiscordFileAttachment>>, files: Option<Vec<PartialDiscordFileAttachment>>,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> { ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url_api = belongs_to.urls.get_api(); let url_api = belongs_to.urls.get_api();
let mut requester = LimitedRequester::new().await; let mut requester = LimitedRequester::new().await;
@ -98,14 +98,14 @@ impl UserMeta {
* `limits_instance` - The [`Limits`] of the instance. * `limits_instance` - The [`Limits`] of the instance.
* `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server. * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server.
# Errors # Errors
* [`InstanceServerError`] - If the message cannot be sent. * [`ChorusLibError`] - If the message cannot be sent.
*/ */
pub async fn send_message( pub async fn send_message(
&mut self, &mut self,
message: &mut MessageSendSchema, message: &mut MessageSendSchema,
channel_id: String, channel_id: String,
files: Option<Vec<PartialDiscordFileAttachment>>, files: Option<Vec<PartialDiscordFileAttachment>>,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> { ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
Message::send(self, channel_id, message, files).await Message::send(self, channel_id, message, files).await
} }
} }

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

@ -3,7 +3,7 @@ use reqwest::Client;
use crate::{ use crate::{
instance::UserMeta, instance::UserMeta,
limit::LimitedRequester, limit::LimitedRequester,
types::{self, Snowflake}, types::{self},
}; };
/** /**
@ -23,7 +23,7 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`]. A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
Fires a `Message Reaction Remove All` Gateway event. Fires a `Message Reaction Remove All` Gateway event.
# Reference # Reference
@ -32,7 +32,7 @@ impl ReactionMeta {
pub async fn delete_all( pub async fn delete_all(
&self, &self,
user: &mut UserMeta, user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> { ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/", "{}/channels/{}/messages/{}/reactions/",
@ -62,7 +62,7 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`]. A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
# Reference # Reference
See [https://discord.com/developers/docs/resources/channel#get-reactions](https://discord.com/developers/docs/resources/channel#get-reactions) See [https://discord.com/developers/docs/resources/channel#get-reactions](https://discord.com/developers/docs/resources/channel#get-reactions)
@ -71,7 +71,7 @@ impl ReactionMeta {
&self, &self,
emoji: &str, emoji: &str,
user: &mut UserMeta, user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> { ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/", "{}/channels/{}/messages/{}/reactions/{}/",
@ -103,7 +103,7 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`]. A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
Fires a `Message Reaction Remove Emoji` Gateway event. Fires a `Message Reaction Remove Emoji` Gateway event.
# Reference # Reference
@ -113,7 +113,7 @@ impl ReactionMeta {
&self, &self,
emoji: &str, emoji: &str,
user: &mut UserMeta, user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> { ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/", "{}/channels/{}/messages/{}/reactions/{}/",
@ -148,7 +148,7 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`]. A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
Returns a 204 empty response on success. Returns a 204 empty response on success.
Fires a Message Reaction Add Gateway event. Fires a Message Reaction Add Gateway event.
@ -159,7 +159,7 @@ impl ReactionMeta {
&self, &self,
emoji: &str, emoji: &str,
user: &mut UserMeta, user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> { ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/@me/", "{}/channels/{}/messages/{}/reactions/{}/@me/",
@ -190,7 +190,7 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`]. A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
Returns a 204 empty response on success. Returns a 204 empty response on success.
Fires a `Message Reaction Remove` Gateway event. Fires a `Message Reaction Remove` Gateway event.
@ -201,7 +201,7 @@ impl ReactionMeta {
&self, &self,
emoji: &str, emoji: &str,
user: &mut UserMeta, user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> { ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/@me/", "{}/channels/{}/messages/{}/reactions/{}/@me/",
@ -235,7 +235,7 @@ impl ReactionMeta {
* `user` - A mutable reference to a [`UserMeta`] instance. * `user` - A mutable reference to a [`UserMeta`] instance.
# Returns # Returns
A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`]. A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`].
Returns a 204 empty response on success. Returns a 204 empty response on success.
Fires a Message Reaction Remove Gateway event. Fires a Message Reaction Remove Gateway event.
@ -247,7 +247,7 @@ impl ReactionMeta {
user_id: &str, user_id: &str,
emoji: &str, emoji: &str,
user: &mut UserMeta, user: &mut UserMeta,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> { ) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!( let url = format!(
"{}/channels/{}/messages/{}/reactions/{}/{}", "{}/channels/{}/messages/{}/reactions/{}/{}",

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

@ -3,7 +3,7 @@ use serde_json::from_str;
use serde_json::to_string; use serde_json::to_string;
use crate::api::limits::Limits; use crate::api::limits::Limits;
use crate::errors::InstanceServerError; use crate::errors::ChorusLibError;
use crate::instance::UserMeta; use crate::instance::UserMeta;
use crate::limit::LimitedRequester; use crate::limit::LimitedRequester;
use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateResponse, GuildCreateSchema}; use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateResponse, GuildCreateSchema};
@ -23,12 +23,12 @@ impl Guild {
/// ///
/// # Errors /// # Errors
/// ///
/// Returns an `InstanceServerError` if the request fails. /// Returns an `ChorusLibError` if the request fails.
/// ///
pub async fn create( pub async fn create(
user: &mut UserMeta, user: &mut UserMeta,
guild_create_schema: GuildCreateSchema, guild_create_schema: GuildCreateSchema,
) -> Result<Guild, crate::errors::InstanceServerError> { ) -> Result<Guild, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!("{}/guilds/", belongs_to.urls.get_api()); let url = format!("{}/guilds/", belongs_to.urls.get_api());
let request = reqwest::Client::new() let request = reqwest::Client::new()
@ -71,7 +71,7 @@ impl Guild {
/// ///
/// # Returns /// # Returns
/// ///
/// An `Option` containing an `InstanceServerError` if an error occurred during the request, otherwise `None`. /// An `Option` containing an `ChorusLibError` if an error occurred during the request, otherwise `None`.
/// ///
/// # Example /// # Example
/// ///
@ -85,7 +85,7 @@ impl Guild {
/// None => println!("Guild deleted successfully"), /// None => println!("Guild deleted successfully"),
/// } /// }
/// ``` /// ```
pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option<InstanceServerError> { pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option<ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!("{}/guilds/{}/delete/", belongs_to.urls.get_api(), guild_id); let url = format!("{}/guilds/{}/delete/", belongs_to.urls.get_api(), guild_id);
let request = reqwest::Client::new() let request = reqwest::Client::new()
@ -119,12 +119,12 @@ impl Guild {
/// ///
/// # Returns /// # Returns
/// ///
/// A `Result` containing a `reqwest::Response` if the request was successful, or an `InstanceServerError` if there was an error. /// A `Result` containing a `reqwest::Response` if the request was successful, or an `ChorusLibError` if there was an error.
pub async fn create_channel( pub async fn create_channel(
&self, &self,
user: &mut UserMeta, user: &mut UserMeta,
schema: ChannelCreateSchema, schema: ChannelCreateSchema,
) -> Result<Channel, InstanceServerError> { ) -> Result<Channel, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
Channel::_create( Channel::_create(
&user.token, &user.token,
@ -137,7 +137,7 @@ impl Guild {
.await .await
} }
/// Returns a `Result` containing a vector of `Channel` structs if the request was successful, or an `InstanceServerError` if there was an error. /// Returns a `Result` containing a vector of `Channel` structs if the request was successful, or an `ChorusLibError` if there was an error.
/// ///
/// # Arguments /// # Arguments
/// ///
@ -146,7 +146,7 @@ impl Guild {
/// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits. /// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits.
/// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits. /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits.
/// ///
pub async fn channels(&self, user: &mut UserMeta) -> Result<Vec<Channel>, InstanceServerError> { pub async fn channels(&self, user: &mut UserMeta) -> Result<Vec<Channel>, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
let request = Client::new() let request = Client::new()
.get(format!( .get(format!(
@ -171,7 +171,7 @@ impl Guild {
let stringed_response = match result.text().await { let stringed_response = match result.text().await {
Ok(value) => value, Ok(value) => value,
Err(e) => { Err(e) => {
return Err(InstanceServerError::InvalidResponseError { return Err(ChorusLibError::InvalidResponseError {
error: e.to_string(), error: e.to_string(),
}) })
} }
@ -179,14 +179,14 @@ impl Guild {
let _: Vec<Channel> = match from_str(&stringed_response) { let _: Vec<Channel> = match from_str(&stringed_response) {
Ok(result) => return Ok(result), Ok(result) => return Ok(result),
Err(e) => { Err(e) => {
return Err(InstanceServerError::InvalidResponseError { return Err(ChorusLibError::InvalidResponseError {
error: e.to_string(), error: e.to_string(),
}) })
} }
}; };
} }
/// Returns a `Result` containing a `Guild` struct if the request was successful, or an `InstanceServerError` if there was an error. /// Returns a `Result` containing a `Guild` struct if the request was successful, or an `ChorusLibError` if there was an error.
/// ///
/// # Arguments /// # Arguments
/// ///
@ -196,7 +196,7 @@ impl Guild {
/// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits. /// * `limits_user` - A mutable reference to a `Limits` struct containing the user's rate limits.
/// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits. /// * `limits_instance` - A mutable reference to a `Limits` struct containing the instance's rate limits.
/// ///
pub async fn get(user: &mut UserMeta, guild_id: &str) -> Result<Guild, InstanceServerError> { pub async fn get(user: &mut UserMeta, guild_id: &str) -> Result<Guild, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
Guild::_get( Guild::_get(
&format!("{}", belongs_to.urls.get_api()), &format!("{}", belongs_to.urls.get_api()),
@ -216,7 +216,7 @@ impl Guild {
token: &str, token: &str,
limits_user: &mut Limits, limits_user: &mut Limits,
limits_instance: &mut Limits, limits_instance: &mut Limits,
) -> Result<Guild, InstanceServerError> { ) -> Result<Guild, ChorusLibError> {
let request = Client::new() let request = Client::new()
.get(format!("{}/guilds/{}/", url_api, guild_id)) .get(format!("{}/guilds/{}/", url_api, guild_id))
.bearer_auth(token); .bearer_auth(token);
@ -252,12 +252,12 @@ impl Channel {
/// ///
/// # Returns /// # Returns
/// ///
/// A `Result` containing a `reqwest::Response` if the request was successful, or an `InstanceServerError` if there was an error. /// A `Result` containing a `reqwest::Response` if the request was successful, or an `ChorusLibError` if there was an error.
pub async fn create( pub async fn create(
user: &mut UserMeta, user: &mut UserMeta,
guild_id: &str, guild_id: &str,
schema: ChannelCreateSchema, schema: ChannelCreateSchema,
) -> Result<Channel, InstanceServerError> { ) -> Result<Channel, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
Channel::_create( Channel::_create(
&user.token, &user.token,
@ -277,7 +277,7 @@ impl Channel {
schema: ChannelCreateSchema, schema: ChannelCreateSchema,
limits_user: &mut Limits, limits_user: &mut Limits,
limits_instance: &mut Limits, limits_instance: &mut Limits,
) -> Result<Channel, InstanceServerError> { ) -> Result<Channel, ChorusLibError> {
let request = Client::new() let request = Client::new()
.post(format!("{}/guilds/{}/channels/", url_api, guild_id)) .post(format!("{}/guilds/{}/channels/", url_api, guild_id))
.bearer_auth(token) .bearer_auth(token)
@ -297,7 +297,7 @@ impl Channel {
}; };
match from_str::<Channel>(&result.text().await.unwrap()) { match from_str::<Channel>(&result.text().await.unwrap()) {
Ok(object) => Ok(object), Ok(object) => Ok(object),
Err(e) => Err(InstanceServerError::RequestErrorError { Err(e) => Err(ChorusLibError::RequestErrorError {
url: format!("{}/guilds/{}/channels/", url_api, guild_id), url: format!("{}/guilds/{}/channels/", url_api, guild_id),
error: e.to_string(), error: e.to_string(),
}), }),

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

@ -1 +1,5 @@
pub mod guilds; pub mod guilds;
pub mod roles;
pub use guilds::*;
pub use roles::*;

109
src/api/guilds/roles.rs Normal file
View File

@ -0,0 +1,109 @@
use reqwest::Client;
use serde_json::{from_str, to_string};
use crate::{
errors::ChorusLibError,
instance::UserMeta,
limit::LimitedRequester,
types::{self, RoleCreateModifySchema, RoleObject},
};
impl types::RoleObject {
/// Retrieves all roles for a given guild.
///
/// # Arguments
///
/// * `user` - A mutable reference to a [`UserMeta`] instance.
/// * `guild_id` - The ID of the guild to retrieve roles from.
///
/// # Returns
///
/// An `Option` containing a `Vec` of [`RoleObject`]s if roles were found, or `None` if no roles were found.
///
/// # Errors
///
/// Returns a [`ChorusLibError`] if the request fails or if the response is invalid.
pub async fn get_all(
user: &mut UserMeta,
guild_id: &str,
) -> Result<Option<Vec<RoleObject>>, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!("{}/guilds/{}/roles/", belongs_to.urls.get_api(), guild_id);
let request = Client::new().get(url).bearer_auth(user.token());
let requester = match LimitedRequester::new()
.await
.send_request(
request,
crate::api::limits::LimitType::Guild,
&mut belongs_to.limits,
&mut user.limits,
)
.await
{
Ok(request) => request,
Err(e) => return Err(e),
};
let roles: Vec<RoleObject> = from_str(&requester.text().await.unwrap()).unwrap();
if roles.is_empty() {
return Ok(None);
}
Ok(Some(roles))
}
/// Creates a new role for a given guild.
///
/// # Arguments
///
/// * `user` - A mutable reference to a [`UserMeta`] instance.
/// * `guild_id` - The ID of the guild to create the role in.
/// * `role_create_schema` - A [`RoleCreateModifySchema`] instance containing the properties of the role to be created.
///
/// # Returns
///
/// A `Result` containing the newly created [`RoleObject`] if successful, or a [`ChorusLibError`] if the request fails or if the response is invalid.
///
/// # Errors
///
/// Returns a [`ChorusLibError`] if the request fails or if the response is invalid.
pub async fn create(
user: &mut UserMeta,
guild_id: &str,
role_create_schema: RoleCreateModifySchema,
) -> Result<RoleObject, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!("{}/guilds/{}/roles/", belongs_to.urls.get_api(), guild_id);
let body = match to_string::<RoleCreateModifySchema>(&role_create_schema) {
Ok(string) => string,
Err(e) => {
return Err(ChorusLibError::FormCreationError {
error: e.to_string(),
})
}
};
let request = Client::new().post(url).bearer_auth(user.token()).body(body);
let result = match LimitedRequester::new()
.await
.send_request(
request,
crate::api::limits::LimitType::Guild,
&mut belongs_to.limits,
&mut user.limits,
)
.await
{
Ok(request) => request,
Err(e) => return Err(e),
};
let role: RoleObject = match from_str(&result.text().await.unwrap()) {
Ok(role) => role,
Err(e) => {
return Err(ChorusLibError::InvalidResponseError {
error: e.to_string(),
})
}
};
Ok(role)
}
}

10
src/api/policies/instance/instance.rs
View File

@ -1,7 +1,7 @@
use reqwest::Client; use reqwest::Client;
use serde_json::from_str; use serde_json::from_str;
use crate::errors::InstanceServerError; use crate::errors::ChorusLibError;
use crate::instance::Instance; use crate::instance::Instance;
use crate::types::GeneralConfiguration; use crate::types::GeneralConfiguration;
@ -9,17 +9,17 @@ impl Instance {
/** /**
Gets the instance policies schema. Gets the instance policies schema.
# Errors # Errors
[`InstanceServerError`] - If the request fails. [`ChorusLibError`] - If the request fails.
*/ */
pub async fn general_configuration_schema( pub async fn general_configuration_schema(
&self, &self,
) -> Result<GeneralConfiguration, InstanceServerError> { ) -> Result<GeneralConfiguration, ChorusLibError> {
let client = Client::new(); let client = Client::new();
let endpoint_url = self.urls.get_api().to_string() + "/policies/instance/"; let endpoint_url = self.urls.get_api().to_string() + "/policies/instance/";
let request = match client.get(&endpoint_url).send().await { let request = match client.get(&endpoint_url).send().await {
Ok(result) => result, Ok(result) => result,
Err(e) => { Err(e) => {
return Err(InstanceServerError::RequestErrorError { return Err(ChorusLibError::RequestErrorError {
url: endpoint_url, url: endpoint_url,
error: e.to_string(), error: e.to_string(),
}); });
@ -27,7 +27,7 @@ impl Instance {
}; };
if !request.status().as_str().starts_with('2') { if !request.status().as_str().starts_with('2') {
return Err(InstanceServerError::ReceivedErrorCodeError { return Err(ChorusLibError::ReceivedErrorCodeError {
error_code: request.status().to_string(), error_code: request.status().to_string(),
}); });
} }

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

@ -3,7 +3,7 @@ use serde_json::{from_str, to_string};
use crate::{ use crate::{
api::limits::Limits, api::limits::Limits,
errors::InstanceServerError, errors::ChorusLibError,
instance::{Instance, UserMeta}, instance::{Instance, UserMeta},
limit::LimitedRequester, limit::LimitedRequester,
types::{User, UserModifySchema, UserSettings}, types::{User, UserModifySchema, UserSettings},
@ -18,12 +18,9 @@ impl UserMeta {
* `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved. * `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved.
* `instance_limits` - The [`Limits`] of the instance. * `instance_limits` - The [`Limits`] of the instance.
# Errors # Errors
* [`InstanceServerError`] - If the request fails. * [`ChorusLibError`] - If the request fails.
*/ */
pub async fn get( pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result<User, ChorusLibError> {
user: &mut UserMeta,
id: Option<&String>,
) -> Result<User, InstanceServerError> {
User::get(user, id).await User::get(user, id).await
} }
@ -31,7 +28,7 @@ impl UserMeta {
token: &String, token: &String,
url_api: &String, url_api: &String,
instance_limits: &mut Limits, instance_limits: &mut Limits,
) -> Result<UserSettings, InstanceServerError> { ) -> Result<UserSettings, ChorusLibError> {
User::get_settings(token, url_api, instance_limits).await User::get_settings(token, url_api, instance_limits).await
} }
@ -43,16 +40,16 @@ impl UserMeta {
/// ///
/// # Errors /// # Errors
/// ///
/// Returns an `InstanceServerError` if the request fails or if a password is required but not provided. /// Returns an `ChorusLibError` if the request fails or if a password is required but not provided.
pub async fn modify( pub async fn modify(
&mut self, &mut self,
modify_schema: UserModifySchema, modify_schema: UserModifySchema,
) -> Result<User, InstanceServerError> { ) -> Result<User, ChorusLibError> {
if modify_schema.new_password.is_some() if modify_schema.new_password.is_some()
|| modify_schema.email.is_some() || modify_schema.email.is_some()
|| modify_schema.code.is_some() || modify_schema.code.is_some()
{ {
return Err(InstanceServerError::PasswordRequiredError); return Err(ChorusLibError::PasswordRequiredError);
} }
let request = Client::new() let request = Client::new()
.patch(format!( .patch(format!(
@ -90,8 +87,8 @@ impl UserMeta {
/// ///
/// # Returns /// # Returns
/// ///
/// Returns `None` if the user was successfully deleted, or an `InstanceServerError` if an error occurred. /// Returns `None` if the user was successfully deleted, or an `ChorusLibError` if an error occurred.
pub async fn delete(mut self) -> Option<InstanceServerError> { pub async fn delete(mut self) -> Option<ChorusLibError> {
let mut belongs_to = self.belongs_to.borrow_mut(); let mut belongs_to = self.belongs_to.borrow_mut();
let request = Client::new() let request = Client::new()
.post(format!("{}/users/@me/delete/", belongs_to.urls.get_api())) .post(format!("{}/users/@me/delete/", belongs_to.urls.get_api()))
@ -113,10 +110,7 @@ impl UserMeta {
} }
impl User { impl User {
pub async fn get( pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result<User, ChorusLibError> {
user: &mut UserMeta,
id: Option<&String>,
) -> Result<User, InstanceServerError> {
let mut belongs_to = user.belongs_to.borrow_mut(); let mut belongs_to = user.belongs_to.borrow_mut();
User::_get( User::_get(
&user.token(), &user.token(),
@ -132,7 +126,7 @@ impl User {
url_api: &str, url_api: &str,
limits_instance: &mut Limits, limits_instance: &mut Limits,
id: Option<&String>, id: Option<&String>,
) -> Result<User, InstanceServerError> { ) -> Result<User, ChorusLibError> {
let url: String; let url: String;
if id.is_none() { if id.is_none() {
url = format!("{}/users/@me/", url_api); url = format!("{}/users/@me/", url_api);
@ -163,7 +157,7 @@ impl User {
token: &String, token: &String,
url_api: &String, url_api: &String,
instance_limits: &mut Limits, instance_limits: &mut Limits,
) -> Result<UserSettings, InstanceServerError> { ) -> Result<UserSettings, ChorusLibError> {
let request: reqwest::RequestBuilder = Client::new() let request: reqwest::RequestBuilder = Client::new()
.get(format!("{}/users/@me/settings/", url_api)) .get(format!("{}/users/@me/settings/", url_api))
.bearer_auth(token); .bearer_auth(token);
@ -191,7 +185,7 @@ impl Instance {
* `token` - A valid access token for the API. * `token` - A valid access token for the API.
* `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved. * `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved.
# Errors # Errors
* [`InstanceServerError`] - If the request fails. * [`ChorusLibError`] - If the request fails.
# Notes # Notes
This function is a wrapper around [`User::get`]. This function is a wrapper around [`User::get`].
*/ */
@ -199,7 +193,7 @@ impl Instance {
&mut self, &mut self,
token: String, token: String,
id: Option<&String>, id: Option<&String>,
) -> Result<User, InstanceServerError> { ) -> Result<User, ChorusLibError> {
User::_get( User::_get(
&token, &token,
&self.urls.get_api().to_string(), &self.urls.get_api().to_string(),

3
src/errors.rs
View File

@ -11,7 +11,7 @@ custom_error! {
custom_error! { custom_error! {
#[derive(PartialEq, Eq)] #[derive(PartialEq, Eq)]
pub InstanceServerError pub ChorusLibError
NoResponse = "Did not receive a response from the Server.", NoResponse = "Did not receive a response from the Server.",
RequestErrorError{url:String, error:String} = "An error occured while trying to GET from {url}: {error}", RequestErrorError{url:String, error:String} = "An error occured while trying to GET from {url}: {error}",
ReceivedErrorCodeError{error_code:String} = "Received the following error code while requesting from the route: {error_code}", ReceivedErrorCodeError{error_code:String} = "Received the following error code while requesting from the route: {error_code}",
@ -19,6 +19,7 @@ custom_error! {
InvalidFormBodyError{error_type: String, error:String} = "The server responded with: {error_type}: {error}", InvalidFormBodyError{error_type: String, error:String} = "The server responded with: {error_type}: {error}",
RateLimited{bucket:String} = "Ratelimited on Bucket {bucket}", RateLimited{bucket:String} = "Ratelimited on Bucket {bucket}",
MultipartCreationError{error: String} = "Got an error whilst creating the form: {}", MultipartCreationError{error: String} = "Got an error whilst creating the form: {}",
FormCreationError{error: String} = "Got an error whilst creating the form: {}",
TokenExpired = "Token expired, invalid or not found.", TokenExpired = "Token expired, invalid or not found.",
NoPermission = "You do not have the permissions needed to perform this action.", NoPermission = "You do not have the permissions needed to perform this action.",
NotFound{error: String} = "The provided resource hasn't been found: {}", NotFound{error: String} = "The provided resource hasn't been found: {}",

6
src/instance.rs
View File

@ -1,7 +1,7 @@
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use crate::api::limits::Limits; use crate::api::limits::Limits;
use crate::errors::{FieldFormatError, InstanceServerError}; use crate::errors::{ChorusLibError, FieldFormatError};
use crate::types::{GeneralConfiguration, User, UserSettings}; use crate::types::{GeneralConfiguration, User, UserSettings};
use crate::URLBundle; use crate::URLBundle;
@ -26,7 +26,7 @@ impl Instance {
/// * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server. /// * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server.
/// # Errors /// # Errors
/// * [`InstanceError`] - If the instance cannot be created. /// * [`InstanceError`] - If the instance cannot be created.
pub async fn new(urls: URLBundle) -> Result<Instance, InstanceServerError> { pub async fn new(urls: URLBundle) -> Result<Instance, ChorusLibError> {
let mut instance = Instance { let mut instance = Instance {
urls: urls.clone(), urls: urls.clone(),
instance_info: GeneralConfiguration::new( instance_info: GeneralConfiguration::new(
@ -45,7 +45,7 @@ impl Instance {
instance.instance_info = match instance.general_configuration_schema().await { instance.instance_info = match instance.general_configuration_schema().await {
Ok(schema) => schema, Ok(schema) => schema,
Err(e) => { Err(e) => {
return Err(InstanceServerError::CantGetInfoError { return Err(ChorusLibError::CantGetInfoError {
error: e.to_string(), error: e.to_string(),
}) })
} }

18
src/limit.rs
View File

@ -1,6 +1,6 @@
use crate::{ use crate::{
api::limits::{Limit, LimitType, Limits, LimitsMutRef}, api::limits::{Limit, LimitType, Limits, LimitsMutRef},
errors::InstanceServerError, errors::ChorusLibError,
}; };
use reqwest::{Client, RequestBuilder, Response}; use reqwest::{Client, RequestBuilder, Response};
@ -71,12 +71,12 @@ impl LimitedRequester {
limit_type: LimitType, limit_type: LimitType,
instance_rate_limits: &mut Limits, instance_rate_limits: &mut Limits,
user_rate_limits: &mut Limits, user_rate_limits: &mut Limits,
) -> Result<Response, InstanceServerError> { ) -> Result<Response, ChorusLibError> {
if self.can_send_request(limit_type, instance_rate_limits, user_rate_limits) { if self.can_send_request(limit_type, instance_rate_limits, user_rate_limits) {
let built_request = match request.build() { let built_request = match request.build() {
Ok(request) => request, Ok(request) => request,
Err(e) => { Err(e) => {
return Err(InstanceServerError::RequestErrorError { return Err(ChorusLibError::RequestErrorError {
url: "".to_string(), url: "".to_string(),
error: e.to_string(), error: e.to_string(),
}) })
@ -86,7 +86,7 @@ impl LimitedRequester {
let response = match result { let response = match result {
Ok(is_response) => is_response, Ok(is_response) => is_response,
Err(e) => { Err(e) => {
return Err(InstanceServerError::ReceivedErrorCodeError { return Err(ChorusLibError::ReceivedErrorCodeError {
error_code: e.to_string(), error_code: e.to_string(),
}) })
} }
@ -99,10 +99,10 @@ impl LimitedRequester {
); );
if !response.status().is_success() { if !response.status().is_success() {
match response.status().as_u16() { match response.status().as_u16() {
401 => return Err(InstanceServerError::TokenExpired), 401 => return Err(ChorusLibError::TokenExpired),
403 => return Err(InstanceServerError::TokenExpired), 403 => return Err(ChorusLibError::TokenExpired),
_ => { _ => {
return Err(InstanceServerError::ReceivedErrorCodeError { return Err(ChorusLibError::ReceivedErrorCodeError {
error_code: response.status().as_str().to_string(), error_code: response.status().as_str().to_string(),
}) })
} }
@ -115,7 +115,7 @@ impl LimitedRequester {
request, request,
limit_type, limit_type,
}); });
Err(InstanceServerError::RateLimited { Err(ChorusLibError::RateLimited {
bucket: limit_type.to_string(), bucket: limit_type.to_string(),
}) })
} }
@ -302,7 +302,7 @@ mod rate_limit {
String::from("http://localhost:3001/cdn"), String::from("http://localhost:3001/cdn"),
); );
let mut requester = LimitedRequester::new().await; let mut requester = LimitedRequester::new().await;
let mut request: Option<Result<Response, InstanceServerError>> = None; let mut request: Option<Result<Response, ChorusLibError>> = None;
let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await; let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await; let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;

113
src/types/entities/guild.rs
View File

@ -13,80 +13,81 @@ use crate::types::{
#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)] #[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
#[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))] #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
pub struct Guild { pub struct Guild {
pub id: Snowflake,
pub name: Option<String>,
pub icon: Option<String>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub icon_hash: Option<String>,
pub splash: Option<String>,
pub discovery_splash: Option<String>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub owner: Option<bool>, // True if requesting user is owner
pub owner_id: Option<Snowflake>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub permissions: Option<String>,
pub afk_channel_id: Option<Snowflake>, pub afk_channel_id: Option<Snowflake>,
pub afk_timeout: Option<i32>, pub afk_timeout: Option<i32>,
pub widget_enabled: Option<bool>,
pub widget_channel_id: Option<Snowflake>,
pub verification_level: Option<i32>,
pub default_message_notifications: Option<i32>,
pub explicit_content_filter: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub roles: Option<Vec<RoleObject>>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
#[serde(default)]
pub emojis: Vec<Emoji>,
//#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))]
pub features: Option<GuildFeaturesList>,
#[cfg_attr(feature = "sqlx", sqlx(skip))] #[cfg_attr(feature = "sqlx", sqlx(skip))]
pub application_id: Option<String>, pub application_id: Option<String>,
pub system_channel_id: Option<Snowflake>,
pub system_channel_flags: Option<i32>,
pub rules_channel_id: Option<Snowflake>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub rules_channel: Option<String>,
pub max_presences: Option<i32>,
pub max_members: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub vanity_url_code: Option<String>,
pub description: Option<String>,
pub banner: Option<String>,
pub premium_tier: Option<i32>,
pub premium_subscription_count: Option<i32>,
pub preferred_locale: Option<String>,
pub public_updates_channel_id: Option<Snowflake>,
pub max_video_channel_users: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub max_stage_video_channel_users: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))] #[cfg_attr(feature = "sqlx", sqlx(skip))]
pub approximate_member_count: Option<i32>, pub approximate_member_count: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))] #[cfg_attr(feature = "sqlx", sqlx(skip))]
pub approximate_presence_count: Option<i32>, pub approximate_presence_count: Option<i32>,
#[cfg(feature = "sqlx")] pub banner: Option<String>,
pub welcome_screen: Option<sqlx::types::Json<WelcomeScreenObject>>,
#[cfg(not(feature = "sqlx"))]
pub welcome_screen: Option<WelcomeScreenObject>,
pub nsfw_level: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub stickers: Option<Vec<Sticker>>,
pub premium_progress_bar_enabled: Option<bool>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub joined_at: Option<String>,
#[cfg_attr(feature = "sqlx", sqlx(skip))] #[cfg_attr(feature = "sqlx", sqlx(skip))]
pub bans: Option<Vec<GuildBan>>, pub bans: Option<Vec<GuildBan>>,
pub primary_category_id: Option<Snowflake>,
pub large: Option<bool>,
#[cfg_attr(feature = "sqlx", sqlx(skip))] #[cfg_attr(feature = "sqlx", sqlx(skip))]
pub channels: Option<Vec<Channel>>, pub channels: Option<Vec<Channel>>,
pub default_message_notifications: Option<i32>,
pub description: Option<String>,
pub discovery_splash: Option<String>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
#[serde(default)]
pub emojis: Vec<Emoji>,
pub explicit_content_filter: Option<i32>,
//#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))]
pub features: Option<GuildFeaturesList>,
pub icon: Option<String>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub icon_hash: Option<String>,
pub id: Snowflake,
#[cfg_attr(feature = "sqlx", sqlx(skip))] #[cfg_attr(feature = "sqlx", sqlx(skip))]
pub invites: Option<Vec<GuildInvite>>, pub invites: Option<Vec<GuildInvite>>,
#[cfg_attr(feature = "sqlx", sqlx(skip))] #[cfg_attr(feature = "sqlx", sqlx(skip))]
pub joined_at: Option<String>,
pub large: Option<bool>,
pub max_members: Option<i32>,
pub max_presences: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub max_stage_video_channel_users: Option<i32>,
pub max_video_channel_users: Option<i32>,
pub mfa_level: Option<i32>,
pub name: Option<String>,
pub nsfw_level: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub owner: Option<bool>,
// True if requesting user is owner
pub owner_id: Option<Snowflake>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub permissions: Option<String>,
pub preferred_locale: Option<String>,
pub premium_progress_bar_enabled: Option<bool>,
pub premium_subscription_count: Option<i32>,
pub premium_tier: Option<i32>,
pub primary_category_id: Option<Snowflake>,
pub public_updates_channel_id: Option<Snowflake>,
pub region: Option<String>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub roles: Option<Vec<RoleObject>>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub rules_channel: Option<String>,
pub rules_channel_id: Option<Snowflake>,
pub splash: Option<String>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub stickers: Option<Vec<Sticker>>,
pub system_channel_flags: Option<i32>,
pub system_channel_id: Option<Snowflake>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub vanity_url_code: Option<String>,
pub verification_level: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub voice_states: Option<Vec<VoiceState>>, pub voice_states: Option<Vec<VoiceState>>,
#[cfg_attr(feature = "sqlx", sqlx(skip))] #[cfg_attr(feature = "sqlx", sqlx(skip))]
pub webhooks: Option<Vec<Webhook>>, pub webhooks: Option<Vec<Webhook>>,
pub mfa_level: Option<i32>, #[cfg(feature = "sqlx")]
pub region: Option<String>, pub welcome_screen: Option<sqlx::types::Json<WelcomeScreenObject>>,
#[cfg(not(feature = "sqlx"))]
pub welcome_screen: Option<WelcomeScreenObject>,
pub widget_channel_id: Option<Snowflake>,
pub widget_enabled: Option<bool>,
} }
/// See https://docs.spacebar.chat/routes/#get-/guilds/-guild_id-/bans/-user- /// See https://docs.spacebar.chat/routes/#get-/guilds/-guild_id-/bans/-user-

124
src/types/entities/role.rs
View File

@ -1,5 +1,6 @@
use bitflags::bitflags;
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
use serde_aux::prelude::{deserialize_option_number_from_string, deserialize_string_from_number}; use serde_aux::prelude::deserialize_option_number_from_string;
use crate::types::utils::Snowflake; use crate::types::utils::Snowflake;
@ -15,7 +16,6 @@ pub struct RoleObject {
pub unicode_emoji: Option<String>, pub unicode_emoji: Option<String>,
pub position: u16, pub position: u16,
#[serde(default)] #[serde(default)]
#[serde(deserialize_with = "deserialize_string_from_number")]
pub permissions: String, pub permissions: String,
pub managed: bool, pub managed: bool,
pub mentionable: bool, pub mentionable: bool,
@ -51,77 +51,59 @@ pub struct RoleTags {
// guild_connections: bool, // guild_connections: bool,
} }
#[derive(Debug)] bitflags! {
#[repr(u64)] #[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
pub enum PermissionFlags { pub struct PermissionFlags: u64 {
CreateInstantInvite = 0x0000000000000001, const CREATE_INSTANT_INVITE = 1 << 0;
KickMembers = 0x0000000000000002, const KICK_MEMBERS = 1 << 1;
BanMembers = 0x0000000000000004, const BAN_MEMBERS = 1 << 2;
Administrator = 0x0000000000000008, const ADMINISTRATOR = 1 << 3;
ManageChannels = 0x0000000000000010, const MANAGE_CHANNELS = 1 << 4;
ManageGuild = 0x0000000000000020, const MANAGE_GUILD = 1 << 5;
AddReactions = 0x0000000000000040, const ADD_REACTIONS = 1 << 6;
ViewAuditLog = 0x0000000000000080, const VIEW_AUDIT_LOG = 1 << 7;
PrioritySpeaker = 0x0000000000000100, const PRIORITY_SPEAKER = 1 << 8;
Stream = 0x0000000000000200, const STREAM = 1 << 9;
ViewChannel = 0x0000000000000400, const VIEW_CHANNEL = 1 << 10;
SendMessages = 0x0000000000000800, const SEND_MESSAGES = 1 << 11;
SendTtsMessages = 0x0000000000001000, const SEND_TTS_MESSAGES = 1 << 12;
ManageMessages = 0x0000000000002000, const MANAGE_MESSAGES = 1 << 13;
EmbedLinks = 0x0000000000004000, const EMBED_LINKS = 1 << 14;
AttachFiles = 0x0000000000008000, const ATTACH_FILES = 1 << 15;
ReadMessageHistory = 0x0000000000010000, const READ_MESSAGE_HISTORY = 1 << 16;
MentionEveryone = 0x0000000000020000, const MENTION_EVERYONE = 1 << 17;
UseExternalEmojis = 0x0000000000040000, const USE_EXTERNAL_EMOJIS = 1 << 18;
ViewGuildInsights = 0x0000000000080000, const VIEW_GUILD_INSIGHTS = 1 << 19;
Connect = 0x0000000000100000, const CONNECT = 1 << 20;
Speak = 0x0000000000200000, const SPEAK = 1 << 21;
MuteMembers = 0x0000000000400000, const MUTE_MEMBERS = 1 << 22;
DeafenMembers = 0x0000000000800000, const DEAFEN_MEMBERS = 1 << 23;
MoveMembers = 0x0000000001000000, const MOVE_MEMBERS = 1 << 24;
UseVad = 0x0000000002000000, const USE_VAD = 1 << 25;
ChangeNickname = 0x0000000004000000, const CHANGE_NICKNAME = 1 << 26;
ManageNicknames = 0x0000000008000000, const MANAGE_NICKNAMES = 1 << 27;
ManageRoles = 0x0000000010000000, const MANAGE_ROLES = 1 << 28;
ManageWebhooks = 0x0000000020000000, const MANAGE_WEBHOOKS = 1 << 29;
ManageGuildExpressions = 0x0000000040000000, const MANAGE_GUILD_EXPRESSIONS = 1 << 30;
UseApplicationCommands = 0x0000000080000000, const USE_APPLICATION_COMMANDS = 1 << 31;
RequestToSpeak = 0x0000000100000000, const REQUEST_TO_SPEAK = 1 << 32;
ManageEvents = 0x0000000200000000, const MANAGE_EVENTS = 1 << 33;
ManageThreads = 0x0000000400000000, const MANAGE_THREADS = 1 << 34;
CreatePublicThreads = 0x0000000800000000, const CREATE_PUBLIC_THREADS = 1 << 35;
CreatePrivateThreads = 0x0000001000000000, const CREATE_PRIVATE_THREADS = 1 << 36;
UseExternalStickers = 0x0000002000000000, const USE_EXTERNAL_STICKERS = 1 << 37;
SendMessagesInThreads = 0x0000004000000000, const SEND_MESSAGES_IN_THREADS = 1 << 38;
UseEmbeddedActivities = 0x0000008000000000, const USE_EMBEDDED_ACTIVITIES = 1 << 39;
ModerateMembers = 0x0000010000000000, const MODERATE_MEMBERS = 1 << 40;
ViewCreatorMonetizationAnalytics = 0x0000020000000000, const VIEW_CREATOR_MONETIZATION_ANALYTICS = 1 << 41;
UseSoundboard = 0x0000040000000000, const USE_SOUNDBOARD = 1 << 42;
UseExternalSounds = 0x0000200000000000, const USE_EXTERNAL_SOUNDS = 1 << 45;
SendVoiceMessages = 0x0000400000000000, const SEND_VOICE_MESSAGES = 1 << 46;
}
} }
impl RoleObject { impl PermissionFlags {
/// Checks if the role has a specific permission.
///
/// # Arguments
///
/// * `permission` - The permission to check for.
///
/// # Example
///
/// ```
/// use chorus::types;
/// let mut role = types::RoleObject::default();
/// let permission = types::PermissionFlags::ModerateMembers as u64 | types::PermissionFlags::UseSoundboard as u64;
/// role.permissions = permission.to_string();
/// assert_eq!(true, role.has_permission(types::PermissionFlags::ModerateMembers));
/// assert_eq!(true, role.has_permission(types::PermissionFlags::UseSoundboard));
/// ```
pub fn has_permission(&self, permission: PermissionFlags) -> bool { pub fn has_permission(&self, permission: PermissionFlags) -> bool {
if self.permissions.parse::<u64>().unwrap() & permission as u64 != 0 { self.contains(permission) || self.contains(PermissionFlags::ADMINISTRATOR)
return true;
}
false
} }
} }

28
src/types/schema/guild.rs
View File

@ -1,8 +1,10 @@
use crate::types::entities::Channel; use crate::types::{entities::Channel, Snowflake};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[derive(Debug, Deserialize, Serialize)] #[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")] #[serde(rename_all = "snake_case")]
/// Represents the schema which needs to be sent to create a Guild.
/// See: [https://docs.spacebar.chat/routes/#cmp--schemas-guildcreateschema](https://docs.spacebar.chat/routes/#cmp--schemas-guildcreateschema)
pub struct GuildCreateSchema { pub struct GuildCreateSchema {
pub name: Option<String>, pub name: Option<String>,
pub region: Option<String>, pub region: Option<String>,
@ -12,3 +14,27 @@ pub struct GuildCreateSchema {
pub system_channel_id: Option<String>, pub system_channel_id: Option<String>,
pub rules_channel_id: Option<String>, pub rules_channel_id: Option<String>,
} }
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
/// Represents the schema which needs to be sent to create or modify a Role.
/// See: [https://docs.spacebar.chat/routes/#cmp--schemas-rolemodifyschema](https://docs.spacebar.chat/routes/#cmp--schemas-rolemodifyschema)
pub struct RoleCreateModifySchema {
pub name: Option<String>,
pub permissions: Option<String>,
pub color: Option<u32>,
pub hoist: Option<bool>,
pub icon: Option<Vec<u8>>,
pub unicode_emoji: Option<String>,
pub mentionable: Option<bool>,
pub position: Option<i32>,
}
#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "snake_case")]
/// Represents the schema which needs to be sent to update a roles' position.
/// See: [https://docs.spacebar.chat/routes/#cmp--schemas-rolepositionupdateschema](https://docs.spacebar.chat/routes/#cmp--schemas-rolepositionupdateschema)
pub struct RolePositionUpdateSchema {
pub id: Snowflake,
pub position: i32,
}

34
tests/roles.rs Normal file
View File

@ -0,0 +1,34 @@
mod common;
use chorus::types::{self, RoleCreateModifySchema};
#[tokio::test]
async fn create_and_get_roles() {
let mut bundle = common::setup().await;
let role_create_schema: types::RoleCreateModifySchema = RoleCreateModifySchema {
name: Some("cool person".to_string()),
permissions: Some("2251804225".to_string()),
hoist: Some(true),
icon: None,
unicode_emoji: Some("".to_string()),
mentionable: Some(true),
position: None,
color: None,
};
let guild_id = bundle.guild.id.clone().to_string();
let role = types::RoleObject::create(&mut bundle.user, &guild_id, role_create_schema)
.await
.unwrap();
let expected = types::RoleObject::get_all(&mut bundle.user, &guild_id)
.await
.unwrap()
.unwrap()
.iter()
.nth(1)
.unwrap()
.clone();
assert_eq!(role, expected);
common::teardown(bundle).await
}