From b0a19faa48fe268eaae23c30edb8de77971149ac Mon Sep 17 00:00:00 2001 From: bitfl0wer Date: Thu, 8 Jun 2023 22:16:23 +0200 Subject: [PATCH] Change InstanceServerError to ChorusLibError The name InstanceServerError was chosen without thinking about it too much, very early in development. The new name suits this custom Error type way better, in my opinion. --- src/api/auth/login.rs | 8 +++--- src/api/auth/register.rs | 10 ++++---- src/api/channels/channels.rs | 17 ++++++------- src/api/channels/messages.rs | 8 +++--- src/api/channels/reactions.rs | 24 +++++++++--------- src/api/guilds/guilds.rs | 36 +++++++++++++-------------- src/api/guilds/roles.rs | 20 ++++++++++++--- src/api/policies/instance/instance.rs | 10 ++++---- src/api/users/users.rs | 34 +++++++++++-------------- src/errors.rs | 2 +- src/instance.rs | 6 ++--- src/limit.rs | 18 +++++++------- src/types/schema/guild.rs | 6 +++++ 13 files changed, 105 insertions(+), 94 deletions(-) diff --git a/src/api/auth/login.rs b/src/api/auth/login.rs index 7ecc4de..2481cd6 100644 --- a/src/api/auth/login.rs +++ b/src/api/auth/login.rs @@ -6,7 +6,7 @@ pub mod login { use serde_json::{from_str, json}; use crate::api::limits::LimitType; - use crate::errors::InstanceServerError; + use crate::errors::ChorusLibError; use crate::instance::{Instance, UserMeta}; use crate::limit::LimitedRequester; use crate::types::{ErrorResponse, LoginResult, LoginSchema}; @@ -15,7 +15,7 @@ pub mod login { pub async fn login_account( &mut self, login_schema: &LoginSchema, - ) -> Result { + ) -> Result { let mut requester = LimitedRequester::new().await; let json_schema = json!(login_schema); let client = Client::new(); @@ -34,7 +34,7 @@ pub mod login { ) .await; if response.is_err() { - return Err(InstanceServerError::NoResponse); + return Err(ChorusLibError::NoResponse); } let response_unwrap = response.unwrap(); @@ -49,7 +49,7 @@ pub mod login { 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(); diff --git a/src/api/auth/register.rs b/src/api/auth/register.rs index 2c8f3f9..8ca4735 100644 --- a/src/api/auth/register.rs +++ b/src/api/auth/register.rs @@ -6,7 +6,7 @@ pub mod register { use crate::{ api::limits::LimitType, - errors::InstanceServerError, + errors::ChorusLibError, instance::{Instance, Token, UserMeta}, limit::LimitedRequester, types::{ErrorResponse, RegisterSchema}, @@ -18,12 +18,12 @@ pub mod register { # Arguments * `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user. # Errors - * [`InstanceServerError`] - If the server does not respond. + * [`ChorusLibError`] - If the server does not respond. */ pub async fn register_account( &mut self, register_schema: &RegisterSchema, - ) -> Result { + ) -> Result { let json_schema = json!(register_schema); let mut limited_requester = LimitedRequester::new().await; let client = Client::new(); @@ -42,7 +42,7 @@ pub mod register { ) .await; if response.is_err() { - return Err(InstanceServerError::NoResponse); + return Err(ChorusLibError::NoResponse); } let response_unwrap = response.unwrap(); @@ -59,7 +59,7 @@ pub mod register { 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 settings = diff --git a/src/api/channels/channels.rs b/src/api/channels/channels.rs index ef5139d..7ed9fc7 100644 --- a/src/api/channels/channels.rs +++ b/src/api/channels/channels.rs @@ -2,17 +2,14 @@ use reqwest::Client; use serde_json::{from_str, to_string}; use crate::{ - errors::InstanceServerError, + errors::ChorusLibError, instance::UserMeta, limit::LimitedRequester, types::{Channel, ChannelModifySchema}, }; impl Channel { - pub async fn get( - user: &mut UserMeta, - channel_id: &str, - ) -> Result { + pub async fn get(user: &mut UserMeta, channel_id: &str) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let request = Client::new() .get(format!( @@ -37,7 +34,7 @@ impl Channel { let result_text = result.text().await.unwrap(); match from_str::(&result_text) { Ok(object) => Ok(object), - Err(e) => Err(InstanceServerError::RequestErrorError { + Err(e) => Err(ChorusLibError::RequestErrorError { url: format!("{}/channels/{}/", belongs_to.urls.get_api(), channel_id), error: e.to_string(), }), @@ -56,8 +53,8 @@ impl Channel { /// /// # Returns /// - /// An `Option` that contains an `InstanceServerError` if an error occurred during the request, or `None` if the request was successful. - pub async fn delete(self, user: &mut UserMeta) -> Option { + /// 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 { let mut belongs_to = user.belongs_to.borrow_mut(); let request = Client::new() .delete(format!( @@ -94,12 +91,12 @@ impl Channel { /// /// # 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( modify_data: ChannelModifySchema, channel_id: &str, user: &mut UserMeta, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let request = Client::new() .patch(format!( diff --git a/src/api/channels/messages.rs b/src/api/channels/messages.rs index a181784..d511e24 100644 --- a/src/api/channels/messages.rs +++ b/src/api/channels/messages.rs @@ -17,14 +17,14 @@ impl Message { * `limits_instance` - The [`Limits`] of the instance. * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server. # Errors - * [`InstanceServerError`] - If the message cannot be sent. + * [`ChorusLibError`] - If the message cannot be sent. */ pub async fn send( user: &mut UserMeta, channel_id: String, message: &mut MessageSendSchema, files: Option>, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let url_api = belongs_to.urls.get_api(); let mut requester = LimitedRequester::new().await; @@ -98,14 +98,14 @@ impl UserMeta { * `limits_instance` - The [`Limits`] of the instance. * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server. # Errors - * [`InstanceServerError`] - If the message cannot be sent. + * [`ChorusLibError`] - If the message cannot be sent. */ pub async fn send_message( &mut self, message: &mut MessageSendSchema, channel_id: String, files: Option>, - ) -> Result { + ) -> Result { Message::send(self, channel_id, message, files).await } } diff --git a/src/api/channels/reactions.rs b/src/api/channels/reactions.rs index a1906c2..9bd7adc 100644 --- a/src/api/channels/reactions.rs +++ b/src/api/channels/reactions.rs @@ -23,7 +23,7 @@ impl ReactionMeta { * `user` - A mutable reference to a [`UserMeta`] instance. # 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. # Reference @@ -32,7 +32,7 @@ impl ReactionMeta { pub async fn delete_all( &self, user: &mut UserMeta, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!( "{}/channels/{}/messages/{}/reactions/", @@ -62,7 +62,7 @@ impl ReactionMeta { * `user` - A mutable reference to a [`UserMeta`] instance. # Returns - A `Result` containing a [`reqwest::Response`] or a [`crate::errors::InstanceServerError`]. + A `Result` containing a [`reqwest::Response`] or a [`crate::errors::ChorusLibError`]. # Reference 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, emoji: &str, user: &mut UserMeta, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!( "{}/channels/{}/messages/{}/reactions/{}/", @@ -103,7 +103,7 @@ impl ReactionMeta { * `user` - A mutable reference to a [`UserMeta`] instance. # 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. # Reference @@ -113,7 +113,7 @@ impl ReactionMeta { &self, emoji: &str, user: &mut UserMeta, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!( "{}/channels/{}/messages/{}/reactions/{}/", @@ -148,7 +148,7 @@ impl ReactionMeta { * `user` - A mutable reference to a [`UserMeta`] instance. # 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. Fires a Message Reaction Add Gateway event. @@ -159,7 +159,7 @@ impl ReactionMeta { &self, emoji: &str, user: &mut UserMeta, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!( "{}/channels/{}/messages/{}/reactions/{}/@me/", @@ -190,7 +190,7 @@ impl ReactionMeta { * `user` - A mutable reference to a [`UserMeta`] instance. # 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. Fires a `Message Reaction Remove` Gateway event. @@ -201,7 +201,7 @@ impl ReactionMeta { &self, emoji: &str, user: &mut UserMeta, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!( "{}/channels/{}/messages/{}/reactions/{}/@me/", @@ -235,7 +235,7 @@ impl ReactionMeta { * `user` - A mutable reference to a [`UserMeta`] instance. # 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. Fires a Message Reaction Remove Gateway event. @@ -247,7 +247,7 @@ impl ReactionMeta { user_id: &str, emoji: &str, user: &mut UserMeta, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!( "{}/channels/{}/messages/{}/reactions/{}/{}", diff --git a/src/api/guilds/guilds.rs b/src/api/guilds/guilds.rs index f267e55..56912e7 100644 --- a/src/api/guilds/guilds.rs +++ b/src/api/guilds/guilds.rs @@ -3,7 +3,7 @@ use serde_json::from_str; use serde_json::to_string; use crate::api::limits::Limits; -use crate::errors::InstanceServerError; +use crate::errors::ChorusLibError; use crate::instance::UserMeta; use crate::limit::LimitedRequester; use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateResponse, GuildCreateSchema}; @@ -23,12 +23,12 @@ impl Guild { /// /// # Errors /// - /// Returns an `InstanceServerError` if the request fails. + /// Returns an `ChorusLibError` if the request fails. /// pub async fn create( user: &mut UserMeta, guild_create_schema: GuildCreateSchema, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!("{}/guilds/", belongs_to.urls.get_api()); let request = reqwest::Client::new() @@ -71,7 +71,7 @@ impl Guild { /// /// # 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 /// @@ -85,7 +85,7 @@ impl Guild { /// None => println!("Guild deleted successfully"), /// } /// ``` - pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option { + pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option { let mut belongs_to = user.belongs_to.borrow_mut(); let url = format!("{}/guilds/{}/delete/", belongs_to.urls.get_api(), guild_id); let request = reqwest::Client::new() @@ -119,12 +119,12 @@ impl Guild { /// /// # 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( &self, user: &mut UserMeta, schema: ChannelCreateSchema, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); Channel::_create( &user.token, @@ -137,7 +137,7 @@ impl Guild { .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 /// @@ -146,7 +146,7 @@ impl Guild { /// * `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. /// - pub async fn channels(&self, user: &mut UserMeta) -> Result, InstanceServerError> { + pub async fn channels(&self, user: &mut UserMeta) -> Result, ChorusLibError> { let mut belongs_to = user.belongs_to.borrow_mut(); let request = Client::new() .get(format!( @@ -171,7 +171,7 @@ impl Guild { let stringed_response = match result.text().await { Ok(value) => value, Err(e) => { - return Err(InstanceServerError::InvalidResponseError { + return Err(ChorusLibError::InvalidResponseError { error: e.to_string(), }) } @@ -179,14 +179,14 @@ impl Guild { let _: Vec = match from_str(&stringed_response) { Ok(result) => return Ok(result), Err(e) => { - return Err(InstanceServerError::InvalidResponseError { + return Err(ChorusLibError::InvalidResponseError { 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 /// @@ -196,7 +196,7 @@ impl Guild { /// * `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. /// - pub async fn get(user: &mut UserMeta, guild_id: &str) -> Result { + pub async fn get(user: &mut UserMeta, guild_id: &str) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); Guild::_get( &format!("{}", belongs_to.urls.get_api()), @@ -216,7 +216,7 @@ impl Guild { token: &str, limits_user: &mut Limits, limits_instance: &mut Limits, - ) -> Result { + ) -> Result { let request = Client::new() .get(format!("{}/guilds/{}/", url_api, guild_id)) .bearer_auth(token); @@ -252,12 +252,12 @@ impl Channel { /// /// # 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( user: &mut UserMeta, guild_id: &str, schema: ChannelCreateSchema, - ) -> Result { + ) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); Channel::_create( &user.token, @@ -277,7 +277,7 @@ impl Channel { schema: ChannelCreateSchema, limits_user: &mut Limits, limits_instance: &mut Limits, - ) -> Result { + ) -> Result { let request = Client::new() .post(format!("{}/guilds/{}/channels/", url_api, guild_id)) .bearer_auth(token) @@ -297,7 +297,7 @@ impl Channel { }; match from_str::(&result.text().await.unwrap()) { Ok(object) => Ok(object), - Err(e) => Err(InstanceServerError::RequestErrorError { + Err(e) => Err(ChorusLibError::RequestErrorError { url: format!("{}/guilds/{}/channels/", url_api, guild_id), error: e.to_string(), }), diff --git a/src/api/guilds/roles.rs b/src/api/guilds/roles.rs index 91d0923..86444bb 100644 --- a/src/api/guilds/roles.rs +++ b/src/api/guilds/roles.rs @@ -1,17 +1,17 @@ use reqwest::Client; -use serde_json::from_str; +use serde_json::{from_str, to_string}; use crate::{ instance::UserMeta, limit::LimitedRequester, - types::{self, RoleObject}, + types::{self, RoleCreateModifySchema, RoleObject}, }; impl types::RoleObject { pub async fn get_all( user: &mut UserMeta, guild_id: &str, - ) -> Result>, crate::errors::InstanceServerError> { + ) -> Result>, 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()); @@ -36,4 +36,18 @@ impl types::RoleObject { Ok(Some(roles)) } + + pub async fn create( + user: &mut UserMeta, + guild_id: &str, + role_create_schema: RoleCreateModifySchema, + ) { + 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::(&role_create_schema) { + Ok(string) => string, + Err(e) => + }; + let request = Client::new().post(url).bearer_auth(user.token()).body() + } } diff --git a/src/api/policies/instance/instance.rs b/src/api/policies/instance/instance.rs index f183e11..055568f 100644 --- a/src/api/policies/instance/instance.rs +++ b/src/api/policies/instance/instance.rs @@ -1,7 +1,7 @@ use reqwest::Client; use serde_json::from_str; -use crate::errors::InstanceServerError; +use crate::errors::ChorusLibError; use crate::instance::Instance; use crate::types::GeneralConfiguration; @@ -9,17 +9,17 @@ impl Instance { /** Gets the instance policies schema. # Errors - [`InstanceServerError`] - If the request fails. + [`ChorusLibError`] - If the request fails. */ pub async fn general_configuration_schema( &self, - ) -> Result { + ) -> Result { let client = Client::new(); let endpoint_url = self.urls.get_api().to_string() + "/policies/instance/"; let request = match client.get(&endpoint_url).send().await { Ok(result) => result, Err(e) => { - return Err(InstanceServerError::RequestErrorError { + return Err(ChorusLibError::RequestErrorError { url: endpoint_url, error: e.to_string(), }); @@ -27,7 +27,7 @@ impl Instance { }; if !request.status().as_str().starts_with('2') { - return Err(InstanceServerError::ReceivedErrorCodeError { + return Err(ChorusLibError::ReceivedErrorCodeError { error_code: request.status().to_string(), }); } diff --git a/src/api/users/users.rs b/src/api/users/users.rs index 2cdaa74..ffabd3f 100644 --- a/src/api/users/users.rs +++ b/src/api/users/users.rs @@ -3,7 +3,7 @@ use serde_json::{from_str, to_string}; use crate::{ api::limits::Limits, - errors::InstanceServerError, + errors::ChorusLibError, instance::{Instance, UserMeta}, limit::LimitedRequester, 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. * `instance_limits` - The [`Limits`] of the instance. # Errors - * [`InstanceServerError`] - If the request fails. + * [`ChorusLibError`] - If the request fails. */ - pub async fn get( - user: &mut UserMeta, - id: Option<&String>, - ) -> Result { + pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result { User::get(user, id).await } @@ -31,7 +28,7 @@ impl UserMeta { token: &String, url_api: &String, instance_limits: &mut Limits, - ) -> Result { + ) -> Result { User::get_settings(token, url_api, instance_limits).await } @@ -43,16 +40,16 @@ impl UserMeta { /// /// # 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( &mut self, modify_schema: UserModifySchema, - ) -> Result { + ) -> Result { if modify_schema.new_password.is_some() || modify_schema.email.is_some() || modify_schema.code.is_some() { - return Err(InstanceServerError::PasswordRequiredError); + return Err(ChorusLibError::PasswordRequiredError); } let request = Client::new() .patch(format!( @@ -90,8 +87,8 @@ impl UserMeta { /// /// # Returns /// - /// Returns `None` if the user was successfully deleted, or an `InstanceServerError` if an error occurred. - pub async fn delete(mut self) -> Option { + /// Returns `None` if the user was successfully deleted, or an `ChorusLibError` if an error occurred. + pub async fn delete(mut self) -> Option { let mut belongs_to = self.belongs_to.borrow_mut(); let request = Client::new() .post(format!("{}/users/@me/delete/", belongs_to.urls.get_api())) @@ -113,10 +110,7 @@ impl UserMeta { } impl User { - pub async fn get( - user: &mut UserMeta, - id: Option<&String>, - ) -> Result { + pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result { let mut belongs_to = user.belongs_to.borrow_mut(); User::_get( &user.token(), @@ -132,7 +126,7 @@ impl User { url_api: &str, limits_instance: &mut Limits, id: Option<&String>, - ) -> Result { + ) -> Result { let url: String; if id.is_none() { url = format!("{}/users/@me/", url_api); @@ -163,7 +157,7 @@ impl User { token: &String, url_api: &String, instance_limits: &mut Limits, - ) -> Result { + ) -> Result { let request: reqwest::RequestBuilder = Client::new() .get(format!("{}/users/@me/settings/", url_api)) .bearer_auth(token); @@ -191,7 +185,7 @@ impl Instance { * `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. # Errors - * [`InstanceServerError`] - If the request fails. + * [`ChorusLibError`] - If the request fails. # Notes This function is a wrapper around [`User::get`]. */ @@ -199,7 +193,7 @@ impl Instance { &mut self, token: String, id: Option<&String>, - ) -> Result { + ) -> Result { User::_get( &token, &self.urls.get_api().to_string(), diff --git a/src/errors.rs b/src/errors.rs index 749c8f7..07cae43 100644 --- a/src/errors.rs +++ b/src/errors.rs @@ -11,7 +11,7 @@ custom_error! { custom_error! { #[derive(PartialEq, Eq)] - pub InstanceServerError + pub ChorusLibError NoResponse = "Did not receive a response from the Server.", 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}", diff --git a/src/instance.rs b/src/instance.rs index ce8849d..6121c65 100644 --- a/src/instance.rs +++ b/src/instance.rs @@ -1,7 +1,7 @@ use serde::{Deserialize, Serialize}; use crate::api::limits::Limits; -use crate::errors::{FieldFormatError, InstanceServerError}; +use crate::errors::{ChorusLibError, FieldFormatError}; use crate::types::{GeneralConfiguration, User, UserSettings}; use crate::URLBundle; @@ -26,7 +26,7 @@ impl Instance { /// * `requester` - The [`LimitedRequester`] that will be used to make requests to the Spacebar server. /// # Errors /// * [`InstanceError`] - If the instance cannot be created. - pub async fn new(urls: URLBundle) -> Result { + pub async fn new(urls: URLBundle) -> Result { let mut instance = Instance { urls: urls.clone(), instance_info: GeneralConfiguration::new( @@ -45,7 +45,7 @@ impl Instance { instance.instance_info = match instance.general_configuration_schema().await { Ok(schema) => schema, Err(e) => { - return Err(InstanceServerError::CantGetInfoError { + return Err(ChorusLibError::CantGetInfoError { error: e.to_string(), }) } diff --git a/src/limit.rs b/src/limit.rs index cc058b6..70f5c06 100644 --- a/src/limit.rs +++ b/src/limit.rs @@ -1,6 +1,6 @@ use crate::{ api::limits::{Limit, LimitType, Limits, LimitsMutRef}, - errors::InstanceServerError, + errors::ChorusLibError, }; use reqwest::{Client, RequestBuilder, Response}; @@ -71,12 +71,12 @@ impl LimitedRequester { limit_type: LimitType, instance_rate_limits: &mut Limits, user_rate_limits: &mut Limits, - ) -> Result { + ) -> Result { if self.can_send_request(limit_type, instance_rate_limits, user_rate_limits) { let built_request = match request.build() { Ok(request) => request, Err(e) => { - return Err(InstanceServerError::RequestErrorError { + return Err(ChorusLibError::RequestErrorError { url: "".to_string(), error: e.to_string(), }) @@ -86,7 +86,7 @@ impl LimitedRequester { let response = match result { Ok(is_response) => is_response, Err(e) => { - return Err(InstanceServerError::ReceivedErrorCodeError { + return Err(ChorusLibError::ReceivedErrorCodeError { error_code: e.to_string(), }) } @@ -99,10 +99,10 @@ impl LimitedRequester { ); if !response.status().is_success() { match response.status().as_u16() { - 401 => return Err(InstanceServerError::TokenExpired), - 403 => return Err(InstanceServerError::TokenExpired), + 401 => return Err(ChorusLibError::TokenExpired), + 403 => return Err(ChorusLibError::TokenExpired), _ => { - return Err(InstanceServerError::ReceivedErrorCodeError { + return Err(ChorusLibError::ReceivedErrorCodeError { error_code: response.status().as_str().to_string(), }) } @@ -115,7 +115,7 @@ impl LimitedRequester { request, limit_type, }); - Err(InstanceServerError::RateLimited { + Err(ChorusLibError::RateLimited { bucket: limit_type.to_string(), }) } @@ -302,7 +302,7 @@ mod rate_limit { String::from("http://localhost:3001/cdn"), ); let mut requester = LimitedRequester::new().await; - let mut request: Option> = None; + let mut request: Option> = None; let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await; let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await; diff --git a/src/types/schema/guild.rs b/src/types/schema/guild.rs index 03996ed..a607123 100644 --- a/src/types/schema/guild.rs +++ b/src/types/schema/guild.rs @@ -3,6 +3,8 @@ use serde::{Deserialize, Serialize}; #[derive(Debug, Deserialize, Serialize)] #[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 name: Option, pub region: Option, @@ -15,6 +17,8 @@ pub struct GuildCreateSchema { #[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, pub permissions: Option, @@ -28,6 +32,8 @@ pub struct RoleCreateModifySchema { #[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,