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 513e2b0394
commit 96c7c129f2
No known key found for this signature in database
GPG Key ID: 84BBB60DF895ABF2
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 crate::api::limits::LimitType;
use crate::api::schemas::LoginSchema;
use crate::api::types::{ErrorResponse, LoginResult};
use crate::errors::InstanceServerError;
use crate::instance::Instance;
use crate::instance::{Instance, UserMeta};
use crate::limit::LimitedRequester;
use crate::types::{ErrorResponse, LoginResult, LoginSchema};
impl Instance {
pub async fn login_account(
&mut self,
login_schema: &LoginSchema,
) -> Result<crate::api::types::User, InstanceServerError> {
) -> Result<UserMeta, InstanceServerError> {
let mut requester = LimitedRequester::new().await;
let json_schema = json!(login_schema);
let client = Client::new();
@ -59,7 +58,7 @@ pub mod login {
.get_user(login_result.token.clone(), None)
.await
.unwrap();
let user = crate::api::types::User::new(
let user = UserMeta::new(
Rc::new(RefCell::new(self.clone())),
login_result.token,
cloned_limits,

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

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

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

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

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

@ -3,12 +3,16 @@ use serde_json::from_str;
use serde_json::to_string;
use crate::api::limits::Limits;
use crate::api::schemas;
use crate::api::types;
use crate::errors::InstanceServerError;
use crate::instance::UserMeta;
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.
///
/// # Arguments
@ -38,9 +42,9 @@ impl types::Guild {
/// }
/// ```
pub async fn create(
user: &mut types::User,
user: &mut UserMeta,
url_api: &str,
guild_create_schema: schemas::GuildCreateSchema,
guild_create_schema: GuildCreateSchema,
) -> Result<String, crate::errors::InstanceServerError> {
let url = format!("{}/guilds/", url_api);
let limits_user = user.limits.get_as_mut();
@ -62,7 +66,7 @@ impl types::Guild {
Ok(result) => result,
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)
}
@ -91,7 +95,7 @@ impl types::Guild {
/// }
/// ```
pub async fn delete(
user: &mut types::User,
user: &mut UserMeta,
url_api: &str,
guild_id: String,
) -> Option<InstanceServerError> {
@ -134,14 +138,14 @@ impl types::Guild {
&self,
url_api: &str,
token: &str,
schema: schemas::ChannelCreateSchema,
schema: ChannelCreateSchema,
limits_user: &mut Limits,
limits_instance: &mut Limits,
) -> Result<types::Channel, InstanceServerError> {
types::Channel::create(
) -> Result<Channel, InstanceServerError> {
Channel::create(
token,
url_api,
&self.id,
&self.id.to_string(),
schema,
limits_user,
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.
///
/// # Arguments
@ -169,10 +173,10 @@ impl types::Channel {
token: &str,
url_api: &str,
guild_id: &str,
schema: schemas::ChannelCreateSchema,
schema: ChannelCreateSchema,
limits_user: &mut Limits,
limits_instance: &mut Limits,
) -> Result<types::Channel, InstanceServerError> {
) -> Result<Channel, InstanceServerError> {
let request = Client::new()
.post(format!("{}/guilds/{}/channels/", url_api, guild_id))
.bearer_auth(token)
@ -190,7 +194,7 @@ impl types::Channel {
Ok(result) => result,
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),
Err(e) => Err(InstanceServerError::RequestErrorError {
url: format!("{}/guilds/{}/channels/", url_api, guild_id),

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

@ -6,7 +6,7 @@ use crate::{
errors::InstanceServerError,
instance::{Instance, UserMeta},
limit::LimitedRequester,
types::{User, UserModifySchema},
types::{User, UserModifySchema, UserSettings},
};
impl UserMeta {
@ -56,7 +56,7 @@ impl UserMeta {
token: &String,
url_api: &String,
instance_limits: &mut Limits,
) -> Result<User, InstanceServerError> {
) -> Result<UserSettings, InstanceServerError> {
let request: reqwest::RequestBuilder = Client::new()
.get(format!("{}/users/@me/settings/", url_api))
.bearer_auth(token);

4
src/instance.rs
View File

@ -1,3 +1,5 @@
use serde::{Deserialize, Serialize};
use crate::api::limits::Limits;
use crate::errors::{FieldFormatError, InstanceServerError};
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 token: String,
}

26
tests/integration.rs
View File

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