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

Finish refactor

This commit is contained in:
bitfl0wer 2023-05-26 12:50:16 +02:00
parent f74b9c4c0d
commit 5b324db391
8 changed files with 71 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -6,17 +6,16 @@ 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::api::schemas::LoginSchema;
use crate::api::types::{ErrorResponse, LoginResult};
use crate::errors::InstanceServerError; use crate::errors::InstanceServerError;
use crate::instance::Instance; use crate::instance::{Instance, UserMeta};
use crate::limit::LimitedRequester; use crate::limit::LimitedRequester;
use crate::types::{ErrorResponse, LoginResult, LoginSchema};
impl Instance { impl Instance {
pub async fn login_account( pub async fn login_account(
&mut self, &mut self,
login_schema: &LoginSchema, login_schema: &LoginSchema,
) -> Result<crate::api::types::User, InstanceServerError> { ) -> Result<UserMeta, InstanceServerError> {
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();
@ -59,7 +58,7 @@ pub mod login {
.get_user(login_result.token.clone(), None) .get_user(login_result.token.clone(), None)
.await .await
.unwrap(); .unwrap();
let user = crate::api::types::User::new( let user = UserMeta::new(
Rc::new(RefCell::new(self.clone())), Rc::new(RefCell::new(self.clone())),
login_result.token, login_result.token,
cloned_limits, cloned_limits,

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

@ -5,10 +5,11 @@ pub mod register {
use serde_json::{from_str, json}; use serde_json::{from_str, json};
use crate::{ use crate::{
api::{limits::LimitType, schemas::RegisterSchema, types::ErrorResponse, Token}, api::limits::LimitType,
errors::InstanceServerError, errors::InstanceServerError,
instance::Instance, instance::{Instance, Token, UserMeta},
limit::LimitedRequester, limit::LimitedRequester,
types::{ErrorResponse, RegisterSchema},
}; };
impl Instance { impl Instance {
@ -22,7 +23,7 @@ pub mod register {
pub async fn register_account( pub async fn register_account(
&mut self, &mut self,
register_schema: &RegisterSchema, register_schema: &RegisterSchema,
) -> Result<crate::api::types::User, InstanceServerError> { ) -> Result<UserMeta, InstanceServerError> {
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();
@ -62,14 +63,11 @@ pub mod register {
return Err(InstanceServerError::InvalidFormBodyError { error_type, error }); return Err(InstanceServerError::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 = crate::api::types::User::get_settings( let settings =
&token, UserMeta::get_settings(&token, &self.urls.get_api().to_string(), &mut self.limits)
&self.urls.get_api().to_string(),
&mut self.limits,
)
.await .await
.unwrap(); .unwrap();
let user: crate::api::types::User = crate::api::types::User::new( let user: UserMeta = UserMeta::new(
Rc::new(RefCell::new(self.clone())), Rc::new(RefCell::new(self.clone())),
token.clone(), token.clone(),
cloned_limits, cloned_limits,
@ -83,9 +81,9 @@ pub mod register {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use crate::api::schemas::{AuthUsername, RegisterSchema};
use crate::instance::Instance; use crate::instance::Instance;
use crate::limit::LimitedRequester; use crate::limit::LimitedRequester;
use crate::types::RegisterSchema;
use crate::URLBundle; use crate::URLBundle;
#[tokio::test] #[tokio::test]
@ -98,7 +96,7 @@ mod test {
let limited_requester = LimitedRequester::new().await; let limited_requester = LimitedRequester::new().await;
let mut test_instance = Instance::new(urls.clone()).await.unwrap(); let mut test_instance = Instance::new(urls.clone()).await.unwrap();
let reg = RegisterSchema::new( let reg = RegisterSchema::new(
AuthUsername::new("Hiiii".to_string()).unwrap(), "Hiiii".to_string(),
None, None,
true, true,
None, None,

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

@ -1,9 +1,11 @@
use reqwest::Client; use reqwest::Client;
use serde_json::from_str; use serde_json::from_str;
use crate::{api::limits::Limits, errors::InstanceServerError, limit::LimitedRequester}; use crate::{
api::limits::Limits, errors::InstanceServerError, limit::LimitedRequester, types::Channel,
};
impl types::Channel { impl Channel {
pub async fn get( pub async fn get(
token: &str, token: &str,
url_api: &str, url_api: &str,
@ -28,7 +30,7 @@ impl types::Channel {
Err(e) => return Err(e), Err(e) => return Err(e),
}; };
let result_text = result.text().await.unwrap(); let result_text = result.text().await.unwrap();
match from_str::<types::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(InstanceServerError::RequestErrorError {
url: format!("{}/channels/{}/", url_api, channel_id), url: format!("{}/channels/{}/", url_api, channel_id),

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

@ -5,8 +5,9 @@ pub mod messages {
use serde_json::to_string; use serde_json::to_string;
use crate::api::limits::Limits; use crate::api::limits::Limits;
use crate::api::types::{Message, PartialDiscordFileAttachment, User}; use crate::instance::UserMeta;
use crate::limit::LimitedRequester; use crate::limit::LimitedRequester;
use crate::types::{Message, MessageSendSchema, PartialDiscordFileAttachment, User};
impl Message { impl Message {
/** /**
@ -23,7 +24,7 @@ pub mod messages {
pub async fn send<'a>( pub async fn send<'a>(
url_api: String, url_api: String,
channel_id: String, channel_id: String,
message: &mut crate::api::schemas::MessageSendSchema, message: &mut MessageSendSchema,
files: Option<Vec<PartialDiscordFileAttachment>>, files: Option<Vec<PartialDiscordFileAttachment>>,
token: String, token: String,
limits_user: &mut Limits, limits_user: &mut Limits,
@ -91,10 +92,10 @@ pub mod messages {
} }
} }
impl User { impl UserMeta {
pub async fn send_message( pub async fn send_message(
&mut self, &mut self,
message: &mut crate::api::schemas::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::InstanceServerError> {
@ -116,11 +117,9 @@ pub mod messages {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use crate::{ use crate::instance::UserMeta;
api::{AuthUsername, LoginSchema}, use crate::types::{LoginSchema, MessageSendSchema, PartialDiscordFileAttachment};
instance::Instance, use crate::{instance::Instance, limit::LimitedRequester};
limit::LimitedRequester,
};
use std::io::Read; use std::io::Read;
use std::{cell::RefCell, fs::File}; use std::{cell::RefCell, fs::File};
@ -129,7 +128,7 @@ mod test {
#[tokio::test] #[tokio::test]
async fn send_message() { async fn send_message() {
let channel_id = "1106954414356168802".to_string(); let channel_id = "1106954414356168802".to_string();
let mut message = crate::api::schemas::MessageSendSchema::new( let mut message = MessageSendSchema::new(
None, None,
Some("A Message!".to_string()), Some("A Message!".to_string()),
None, None,
@ -149,7 +148,7 @@ mod test {
.await .await
.unwrap(); .unwrap();
let login_schema: LoginSchema = LoginSchema::new( let login_schema: LoginSchema = LoginSchema::new(
AuthUsername::new("user@test.xyz".to_string()).unwrap(), "user@test.xyz".to_string(),
"transrights".to_string(), "transrights".to_string(),
None, None,
None, None,
@ -162,7 +161,7 @@ mod test {
println!("TOKEN: {}", token); println!("TOKEN: {}", token);
let settings = login_result.settings; let settings = login_result.settings;
let limits = instance.limits.clone(); let limits = instance.limits.clone();
let mut user = crate::api::types::User::new( let mut user = UserMeta::new(
Rc::new(RefCell::new(instance)), Rc::new(RefCell::new(instance)),
token, token,
limits, limits,
@ -185,7 +184,7 @@ mod test {
reader.read_to_end(&mut buffer).unwrap(); reader.read_to_end(&mut buffer).unwrap();
let attachment = crate::api::types::PartialDiscordFileAttachment { let attachment = PartialDiscordFileAttachment {
id: None, id: None,
filename: "README.md".to_string(), filename: "README.md".to_string(),
description: None, description: None,
@ -201,7 +200,7 @@ mod test {
content: buffer, content: buffer,
}; };
let mut message = crate::api::schemas::MessageSendSchema::new( let mut message = MessageSendSchema::new(
None, None,
Some("trans rights now".to_string()), Some("trans rights now".to_string()),
None, None,
@ -221,7 +220,7 @@ mod test {
.await .await
.unwrap(); .unwrap();
let login_schema: LoginSchema = LoginSchema::new( let login_schema: LoginSchema = LoginSchema::new(
AuthUsername::new("user@test.xyz".to_string()).unwrap(), "user@test.xyz".to_string(),
"transrights".to_string(), "transrights".to_string(),
None, None,
None, None,
@ -233,7 +232,7 @@ mod test {
let token = login_result.token; let token = login_result.token;
let settings = login_result.settings; let settings = login_result.settings;
let limits = instance.limits.clone(); let limits = instance.limits.clone();
let mut user = crate::api::types::User::new( let mut user = UserMeta::new(
Rc::new(RefCell::new(instance)), Rc::new(RefCell::new(instance)),
token, token,
limits, limits,

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

@ -3,12 +3,16 @@ 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::api::schemas;
use crate::api::types;
use crate::errors::InstanceServerError; use crate::errors::InstanceServerError;
use crate::instance::UserMeta;
use crate::limit::LimitedRequester; use crate::limit::LimitedRequester;
use crate::types::Channel;
use crate::types::ChannelCreateSchema;
use crate::types::Guild;
use crate::types::GuildCreateResponse;
use crate::types::GuildCreateSchema;
impl types::Guild { impl Guild {
/// Creates a new guild with the given parameters. /// Creates a new guild with the given parameters.
/// ///
/// # Arguments /// # Arguments
@ -38,9 +42,9 @@ impl types::Guild {
/// } /// }
/// ``` /// ```
pub async fn create( pub async fn create(
user: &mut types::User, user: &mut UserMeta,
url_api: &str, url_api: &str,
guild_create_schema: schemas::GuildCreateSchema, guild_create_schema: GuildCreateSchema,
) -> Result<String, crate::errors::InstanceServerError> { ) -> Result<String, crate::errors::InstanceServerError> {
let url = format!("{}/guilds/", url_api); let url = format!("{}/guilds/", url_api);
let limits_user = user.limits.get_as_mut(); let limits_user = user.limits.get_as_mut();
@ -62,7 +66,7 @@ impl types::Guild {
Ok(result) => result, Ok(result) => result,
Err(e) => return Err(e), Err(e) => return Err(e),
}; };
let id: types::GuildCreateResponse = from_str(&result.text().await.unwrap()).unwrap(); let id: GuildCreateResponse = from_str(&result.text().await.unwrap()).unwrap();
Ok(id.id) Ok(id.id)
} }
@ -91,7 +95,7 @@ impl types::Guild {
/// } /// }
/// ``` /// ```
pub async fn delete( pub async fn delete(
user: &mut types::User, user: &mut UserMeta,
url_api: &str, url_api: &str,
guild_id: String, guild_id: String,
) -> Option<InstanceServerError> { ) -> Option<InstanceServerError> {
@ -134,14 +138,14 @@ impl types::Guild {
&self, &self,
url_api: &str, url_api: &str,
token: &str, token: &str,
schema: schemas::ChannelCreateSchema, schema: ChannelCreateSchema,
limits_user: &mut Limits, limits_user: &mut Limits,
limits_instance: &mut Limits, limits_instance: &mut Limits,
) -> Result<types::Channel, InstanceServerError> { ) -> Result<Channel, InstanceServerError> {
types::Channel::create( Channel::create(
token, token,
url_api, url_api,
&self.id, &self.id.to_string(),
schema, schema,
limits_user, limits_user,
limits_instance, limits_instance,
@ -150,7 +154,7 @@ impl types::Guild {
} }
} }
impl types::Channel { impl Channel {
/// Sends a request to create a new channel in a guild. /// Sends a request to create a new channel in a guild.
/// ///
/// # Arguments /// # Arguments
@ -169,10 +173,10 @@ impl types::Channel {
token: &str, token: &str,
url_api: &str, url_api: &str,
guild_id: &str, guild_id: &str,
schema: schemas::ChannelCreateSchema, schema: ChannelCreateSchema,
limits_user: &mut Limits, limits_user: &mut Limits,
limits_instance: &mut Limits, limits_instance: &mut Limits,
) -> Result<types::Channel, InstanceServerError> { ) -> Result<Channel, InstanceServerError> {
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)
@ -190,7 +194,7 @@ impl types::Channel {
Ok(result) => result, Ok(result) => result,
Err(e) => return Err(e), Err(e) => return Err(e),
}; };
match from_str::<types::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(InstanceServerError::RequestErrorError {
url: format!("{}/guilds/{}/channels/", url_api, guild_id), url: format!("{}/guilds/{}/channels/", url_api, guild_id),

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

@ -6,7 +6,7 @@ use crate::{
errors::InstanceServerError, errors::InstanceServerError,
instance::{Instance, UserMeta}, instance::{Instance, UserMeta},
limit::LimitedRequester, limit::LimitedRequester,
types::{User, UserModifySchema}, types::{User, UserModifySchema, UserSettings},
}; };
impl UserMeta { impl UserMeta {
@ -56,7 +56,7 @@ impl UserMeta {
token: &String, token: &String,
url_api: &String, url_api: &String,
instance_limits: &mut Limits, instance_limits: &mut Limits,
) -> Result<User, InstanceServerError> { ) -> Result<UserSettings, InstanceServerError> {
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);

4
src/instance.rs
View File

@ -1,3 +1,5 @@
use serde::{Deserialize, Serialize};
use crate::api::limits::Limits; use crate::api::limits::Limits;
use crate::errors::{FieldFormatError, InstanceServerError}; use crate::errors::{FieldFormatError, InstanceServerError};
use crate::types::{GeneralConfiguration, User, UserSettings}; use crate::types::{GeneralConfiguration, User, UserSettings};
@ -52,7 +54,7 @@ impl Instance {
} }
} }
#[derive(Debug, PartialEq, Eq)] #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct Token { pub struct Token {
pub token: String, pub token: String,
} }

22
tests/integration.rs
View File

@ -1,14 +1,13 @@
use chorus::{ use chorus::{
api::schemas, instance::{Instance, UserMeta},
api::{AuthUsername, Channel, Guild, GuildCreateSchema, RegisterSchema, User}, types::{Channel, ChannelCreateSchema, Guild, GuildCreateSchema, RegisterSchema, User},
instance::Instance,
URLBundle, URLBundle,
}; };
#[derive(Debug)] #[derive(Debug)]
struct TestBundle { struct TestBundle {
urls: URLBundle, urls: URLBundle,
user: User, user: UserMeta,
instance: Instance, instance: Instance,
guild_id: String, guild_id: String,
channel: Channel, channel: Channel,
@ -24,7 +23,7 @@ async fn setup() -> TestBundle {
let mut instance = Instance::new(urls.clone()).await.unwrap(); let mut instance = Instance::new(urls.clone()).await.unwrap();
// Requires the existance of the below user. // Requires the existance of the below user.
let reg = RegisterSchema::new( let reg = RegisterSchema::new(
AuthUsername::new("integrationtestuser".to_string()).unwrap(), "integrationtestuser".to_string(),
None, None,
true, true,
None, None,
@ -45,7 +44,7 @@ async fn setup() -> TestBundle {
system_channel_id: None, system_channel_id: None,
rules_channel_id: None, rules_channel_id: None,
}; };
let channel_create_schema = schemas::ChannelCreateSchema { let channel_create_schema = ChannelCreateSchema {
name: "testchannel".to_string(), name: "testchannel".to_string(),
channel_type: Some(0), channel_type: Some(0),
topic: None, topic: None,
@ -101,13 +100,13 @@ async fn teardown(mut bundle: TestBundle) {
} }
mod guild { mod guild {
use chorus::api::{schemas, types, Channel}; use chorus::types::{Channel, Guild, GuildCreateSchema};
#[tokio::test] #[tokio::test]
async fn guild_creation_deletion() { async fn guild_creation_deletion() {
let mut bundle = crate::setup().await; let mut bundle = crate::setup().await;
let guild_create_schema = schemas::GuildCreateSchema { let guild_create_schema = GuildCreateSchema {
name: Some("test".to_string()), name: Some("test".to_string()),
region: None, region: None,
icon: None, icon: None,
@ -117,14 +116,13 @@ mod guild {
rules_channel_id: None, rules_channel_id: None,
}; };
let guild = let guild = Guild::create(&mut bundle.user, bundle.urls.get_api(), guild_create_schema)
types::Guild::create(&mut bundle.user, bundle.urls.get_api(), guild_create_schema)
.await .await
.unwrap(); .unwrap();
println!("{}", guild); println!("{}", guild);
match types::Guild::delete(&mut bundle.user, bundle.urls.get_api(), guild).await { match Guild::delete(&mut bundle.user, bundle.urls.get_api(), guild).await {
None => assert!(true), None => assert!(true),
Some(_) => assert!(false), Some(_) => assert!(false),
} }
@ -142,7 +140,7 @@ mod guild {
Channel::get( Channel::get(
bundle_user.token.as_str(), bundle_user.token.as_str(),
bundle.instance.urls.get_api(), bundle.instance.urls.get_api(),
&bundle_channel.id, &bundle_channel.id.to_string(),
&mut bundle_user.limits, &mut bundle_user.limits,
&mut bundle.instance.limits &mut bundle.instance.limits
) )