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 2bfa4937d9 bfe395a15b
commit 182cd45a15
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 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<UserMeta, InstanceServerError> {
) -> Result<UserMeta, ChorusLibError> {
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();

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

@ -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<UserMeta, InstanceServerError> {
) -> Result<UserMeta, ChorusLibError> {
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 =

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

@ -2,18 +2,14 @@ use reqwest::Client;
use serde_json::{from_str, to_string};
use crate::{
api::limits::Limits,
errors::InstanceServerError,
errors::ChorusLibError,
instance::UserMeta,
limit::LimitedRequester,
types::{Channel, ChannelModifySchema},
};
impl Channel {
pub async fn get(
user: &mut UserMeta,
channel_id: &str,
) -> Result<Channel, InstanceServerError> {
pub async fn get(user: &mut UserMeta, channel_id: &str) -> Result<Channel, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let request = Client::new()
.get(format!(
@ -38,7 +34,7 @@ impl Channel {
let result_text = result.text().await.unwrap();
match from_str::<Channel>(&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(),
}),
@ -57,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<InstanceServerError> {
/// 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<ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let request = Client::new()
.delete(format!(
@ -95,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<Channel, InstanceServerError> {
) -> Result<Channel, ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let request = Client::new()
.patch(format!(

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

@ -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<Vec<PartialDiscordFileAttachment>>,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
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<Vec<PartialDiscordFileAttachment>>,
) -> Result<reqwest::Response, crate::errors::InstanceServerError> {
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
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::{
instance::UserMeta,
limit::LimitedRequester,
types::{self, Snowflake},
types::{self},
};
/**
@ -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<reqwest::Response, crate::errors::InstanceServerError> {
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
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<reqwest::Response, crate::errors::InstanceServerError> {
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
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<reqwest::Response, crate::errors::InstanceServerError> {
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
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<reqwest::Response, crate::errors::InstanceServerError> {
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
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<reqwest::Response, crate::errors::InstanceServerError> {
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
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<reqwest::Response, crate::errors::InstanceServerError> {
) -> Result<reqwest::Response, crate::errors::ChorusLibError> {
let mut belongs_to = user.belongs_to.borrow_mut();
let url = format!(
"{}/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 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<Guild, crate::errors::InstanceServerError> {
) -> Result<Guild, crate::errors::ChorusLibError> {
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<InstanceServerError> {
pub async fn delete(user: &mut UserMeta, guild_id: &str) -> Option<ChorusLibError> {
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<Channel, InstanceServerError> {
) -> Result<Channel, ChorusLibError> {
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<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 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<Channel> = 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<Guild, InstanceServerError> {
pub async fn get(user: &mut UserMeta, guild_id: &str) -> Result<Guild, ChorusLibError> {
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<Guild, InstanceServerError> {
) -> Result<Guild, ChorusLibError> {
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<Channel, InstanceServerError> {
) -> Result<Channel, ChorusLibError> {
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<Channel, InstanceServerError> {
) -> Result<Channel, ChorusLibError> {
let request = Client::new()
.post(format!("{}/guilds/{}/channels/", url_api, guild_id))
.bearer_auth(token)
@ -297,7 +297,7 @@ impl Channel {
};
match from_str::<Channel>(&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(),
}),

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

@ -1 +1,5 @@
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 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<GeneralConfiguration, InstanceServerError> {
) -> Result<GeneralConfiguration, ChorusLibError> {
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(),
});
}

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

@ -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<User, InstanceServerError> {
pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result<User, ChorusLibError> {
User::get(user, id).await
}
@ -31,7 +28,7 @@ impl UserMeta {
token: &String,
url_api: &String,
instance_limits: &mut Limits,
) -> Result<UserSettings, InstanceServerError> {
) -> Result<UserSettings, ChorusLibError> {
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<User, InstanceServerError> {
) -> Result<User, ChorusLibError> {
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<InstanceServerError> {
/// Returns `None` if the user was successfully deleted, or an `ChorusLibError` if an error occurred.
pub async fn delete(mut self) -> Option<ChorusLibError> {
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<User, InstanceServerError> {
pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result<User, ChorusLibError> {
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<User, InstanceServerError> {
) -> Result<User, ChorusLibError> {
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<UserSettings, InstanceServerError> {
) -> Result<UserSettings, ChorusLibError> {
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<User, InstanceServerError> {
) -> Result<User, ChorusLibError> {
User::_get(
&token,
&self.urls.get_api().to_string(),

3
src/errors.rs
View File

@ -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}",
@ -19,6 +19,7 @@ custom_error! {
InvalidFormBodyError{error_type: String, error:String} = "The server responded with: {error_type}: {error}",
RateLimited{bucket:String} = "Ratelimited on Bucket {bucket}",
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.",
NoPermission = "You do not have the permissions needed to perform this action.",
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 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<Instance, InstanceServerError> {
pub async fn new(urls: URLBundle) -> Result<Instance, ChorusLibError> {
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(),
})
}

18
src/limit.rs
View File

@ -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<Response, InstanceServerError> {
) -> Result<Response, ChorusLibError> {
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<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 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)]
#[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
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_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))]
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))]
pub approximate_member_count: Option<i32>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub approximate_presence_count: Option<i32>,
#[cfg(feature = "sqlx")]
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>,
pub banner: Option<String>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub bans: Option<Vec<GuildBan>>,
pub primary_category_id: Option<Snowflake>,
pub large: Option<bool>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
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))]
pub invites: Option<Vec<GuildInvite>>,
#[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>>,
#[cfg_attr(feature = "sqlx", sqlx(skip))]
pub webhooks: Option<Vec<Webhook>>,
pub mfa_level: Option<i32>,
pub region: Option<String>,
#[cfg(feature = "sqlx")]
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-

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

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

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};
#[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<String>,
pub region: Option<String>,
@ -12,3 +14,27 @@ pub struct GuildCreateSchema {
pub system_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
}