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

Start refactoring ChorusRequest to ChorusRequest::new()

This commit is contained in:
bitfl0wer 2023-08-25 00:02:26 +02:00
parent dd20cb6d9b
commit 6106bdf1cb
No known key found for this signature in database
GPG Key ID: 0ACD574FCF5226CF
10 changed files with 371 additions and 298 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -16,13 +16,20 @@ impl Channel {
/// # Reference /// # Reference
/// See <https://discord-userdoccers.vercel.app/resources/channel#get-channel> /// See <https://discord-userdoccers.vercel.app/resources/channel#get-channel>
pub async fn get(user: &mut ChorusUser, channel_id: Snowflake) -> ChorusResult<Channel> { pub async fn get(user: &mut ChorusUser, channel_id: Snowflake) -> ChorusResult<Channel> {
let url = user.belongs_to.borrow().urls.api.clone(); let chorus_request = ChorusRequest::new(
let chorus_request = ChorusRequest { http::Method::GET,
request: Client::new() &format!(
.get(format!("{}/channels/{}", url, channel_id)) "{}/channels/{}",
.header("Authorization", user.token()), user.belongs_to.borrow().urls.api.clone(),
limit_type: LimitType::Channel(channel_id), channel_id
}; ),
None,
None,
None,
Some(user),
LimitType::Channel(channel_id),
);
chorus_request.deserialize_response::<Channel>(user).await chorus_request.deserialize_response::<Channel>(user).await
} }
@ -38,21 +45,19 @@ impl Channel {
audit_log_reason: Option<String>, audit_log_reason: Option<String>,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let mut request = Client::new() let url = format!("{}/channels/{}", user.belongs_to.borrow().urls.api, self.id,);
.delete(format!(
"{}/channels/{}", let request = ChorusRequest::new(
user.belongs_to.borrow().urls.api, http::Method::DELETE,
self.id &url,
)) None,
.header("Authorization", user.token()); audit_log_reason.as_deref(),
if let Some(reason) = audit_log_reason { None,
request = request.header("X-Audit-Log-Reason", reason); Some(user),
} LimitType::Channel(self.id),
let chorus_request = ChorusRequest { );
request,
limit_type: LimitType::Channel(self.id), request.handle_request_as_result(user).await
};
chorus_request.handle_request_as_result(user).await
} }
/// Modifies a channel with the provided data. /// Modifies a channel with the provided data.
@ -76,23 +81,23 @@ impl Channel {
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<Channel> { ) -> ChorusResult<Channel> {
let channel_id = self.id; let channel_id = self.id;
let mut request = Client::new() let url = format!(
.patch(format!( "{}/channels/{}",
"{}/channels/{}", user.belongs_to.borrow().urls.api,
user.belongs_to.borrow().urls.api, channel_id
channel_id );
))
.header("Authorization", user.token()) let request = ChorusRequest::new(
.header("Content-Type", "application/json") http::Method::PATCH,
.body(to_string(&modify_data).unwrap()); &url,
if let Some(reason) = audit_log_reason { Some(to_string(&modify_data).unwrap()),
request = request.header("X-Audit-Log-Reason", reason); audit_log_reason.as_deref(),
} None,
let chorus_request = ChorusRequest { Some(user),
request, LimitType::Channel(channel_id),
limit_type: LimitType::Channel(channel_id), );
};
chorus_request.deserialize_response::<Channel>(user).await request.deserialize_response::<Channel>(user).await
} }
/// Fetches recent messages from a channel. /// Fetches recent messages from a channel.
@ -109,17 +114,22 @@ impl Channel {
channel_id: Snowflake, channel_id: Snowflake,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> Result<Vec<Message>, ChorusError> { ) -> Result<Vec<Message>, ChorusError> {
let chorus_request = ChorusRequest { let url = format!(
request: Client::new() "{}/channels/{}/messages",
.get(format!( user.belongs_to.borrow().urls.api,
"{}/channels/{}/messages", channel_id
user.belongs_to.borrow().urls.api, );
channel_id
)) let mut chorus_request = ChorusRequest::new(
.header("Authorization", user.token()) http::Method::GET,
.query(&range), &url,
limit_type: Default::default(), None,
}; None,
None,
Some(user),
Default::default(),
);
chorus_request.request = chorus_request.request.query(&range);
chorus_request chorus_request
.deserialize_response::<Vec<Message>>(user) .deserialize_response::<Vec<Message>>(user)
@ -165,20 +175,24 @@ impl Channel {
recipient_id: Snowflake, recipient_id: Snowflake,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let request = Client::new() let url = format!(
.delete(format!( "{}/channels/{}/recipients/{}",
"{}/channels/{}/recipients/{}", user.belongs_to.borrow().urls.api,
user.belongs_to.borrow().urls.api, self.id,
self.id, recipient_id
recipient_id );
))
.header("Authorization", user.token()); let request = ChorusRequest::new(
ChorusRequest { http::Method::DELETE,
request, &url,
limit_type: LimitType::Channel(self.id), None,
} None,
.handle_request_as_result(user) None,
.await Some(user),
LimitType::Channel(self.id),
);
request.handle_request_as_result(user).await
} }
/// Modifies the positions of a set of channel objects for the guild. Requires the `MANAGE_CHANNELS` permission. /// Modifies the positions of a set of channel objects for the guild. Requires the `MANAGE_CHANNELS` permission.
@ -191,19 +205,22 @@ impl Channel {
guild_id: Snowflake, guild_id: Snowflake,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let request = Client::new() let url = format!(
.patch(format!( "{}/guilds/{}/channels",
"{}/guilds/{}/channels", user.belongs_to.borrow().urls.api,
user.belongs_to.borrow().urls.api, guild_id
guild_id );
))
.header("Authorization", user.token()) let request = ChorusRequest::new(
.body(to_string(&schema).unwrap()); http::Method::PATCH,
ChorusRequest { &url,
request, Some(to_string(&schema).unwrap()),
limit_type: LimitType::Guild(guild_id), None,
} None,
.handle_request_as_result(user) Some(user),
.await LimitType::Guild(guild_id),
);
request.handle_request_as_result(user).await
} }
} }

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

@ -138,17 +138,20 @@ impl Message {
channel_id: Snowflake, channel_id: Snowflake,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<Vec<Message>> { ) -> ChorusResult<Vec<Message>> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest::new(
request: Client::new() http::Method::GET,
.get(format!( format!(
"{}/channels/{}/pins", "{}/channels/{}/pins",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
channel_id channel_id
)) )
.header("Authorization", user.token()) .as_str(),
.header("Content-Type", "application/json"), None,
limit_type: LimitType::Channel(channel_id), None,
}; None,
Some(user),
LimitType::Channel(channel_id),
);
chorus_request chorus_request
.deserialize_response::<Vec<Message>>(user) .deserialize_response::<Vec<Message>>(user)
.await .await
@ -162,26 +165,25 @@ impl Message {
pub async fn sticky( pub async fn sticky(
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
audit_log_reason: Option<String>, audit_log_reason: Option<&str>,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let mut request = Client::new() let request = ChorusRequest::new(
.put(format!( http::Method::PUT,
format!(
"{}/channels/{}/pins/{}", "{}/channels/{}/pins/{}",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
channel_id, channel_id,
message_id message_id
)) )
.header("Authorization", user.token()) .as_str(),
.header("Content-Type", "application/json"); None,
if let Some(reason) = audit_log_reason { audit_log_reason,
request = request.header("X-Audit-Log-Reason", reason); None,
} Some(user),
let chorus_request = ChorusRequest { LimitType::Channel(channel_id),
request, );
limit_type: LimitType::Channel(channel_id), request.handle_request_as_result(user).await
};
chorus_request.handle_request_as_result(user).await
} }
/// Unpins a message in a channel. Requires the `MANAGE_MESSAGES` permission. Returns a 204 empty response on success. /// Unpins a message in a channel. Requires the `MANAGE_MESSAGES` permission. Returns a 204 empty response on success.
@ -190,26 +192,25 @@ impl Message {
pub async fn unsticky( pub async fn unsticky(
channel_id: Snowflake, channel_id: Snowflake,
message_id: Snowflake, message_id: Snowflake,
audit_log_reason: Option<String>, audit_log_reason: Option<&str>,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let mut request = Client::new() let request = ChorusRequest::new(
.delete(format!( http::Method::DELETE,
format!(
"{}/channels/{}/pins/{}", "{}/channels/{}/pins/{}",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
channel_id, channel_id,
message_id message_id
)) )
.header("Authorization", user.token()) .as_str(),
.header("Content-Type", "application/json"); None,
if let Some(reason) = audit_log_reason { audit_log_reason,
request = request.header("X-Audit-Log-Reason", reason); None,
} Some(user),
let chorus_request = ChorusRequest { LimitType::Channel(channel_id),
request, );
limit_type: LimitType::Channel(channel_id), request.handle_request_as_result(user).await
};
chorus_request.handle_request_as_result(user).await
} }
/// Returns a specific message object in the channel. /// Returns a specific message object in the channel.
@ -244,19 +245,21 @@ impl Message {
schema: CreateGreetMessage, schema: CreateGreetMessage,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<Message> { ) -> ChorusResult<Message> {
let chorus_request = ChorusRequest { let request = ChorusRequest::new(
request: Client::new() http::Method::POST,
.post(format!( format!(
"{}/channels/{}/messages/greet", "{}/channels/{}/messages/greet",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
channel_id, channel_id,
)) )
.header("Authorization", user.token()) .as_str(),
.header("Content-Type", "application/json") Some(to_string(&schema).unwrap()),
.body(to_string(&schema).unwrap()), None,
limit_type: LimitType::Channel(channel_id), None,
}; Some(user),
chorus_request.deserialize_response::<Message>(user).await LimitType::Channel(channel_id),
);
request.deserialize_response::<Message>(user).await
} }
/// Sets the channel's latest acknowledged message (marks a message as read) for the current user. /// Sets the channel's latest acknowledged message (marks a message as read) for the current user.
@ -275,22 +278,22 @@ impl Message {
schema: MessageAck, schema: MessageAck,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<Option<String>> { ) -> ChorusResult<Option<String>> {
let chorus_request = ChorusRequest { let request = ChorusRequest::new(
request: Client::new() http::Method::POST,
.post(format!( format!(
"{}/channels/{}/messages/{}/ack", "{}/channels/{}/messages/{}/ack",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
channel_id, channel_id,
message_id message_id
)) )
.header("Authorization", user.token()) .as_str(),
.header("Content-Type", "application/json") Some(to_string(&schema).unwrap()),
.body(to_string(&schema).unwrap()), None,
limit_type: LimitType::Channel(channel_id), None,
}; Some(user),
chorus_request LimitType::Channel(channel_id),
.deserialize_response::<Option<String>>(user) );
.await request.deserialize_response::<Option<String>>(user).await
} }
/// Crossposts a message in a News Channel to following channels. /// Crossposts a message in a News Channel to following channels.
@ -304,19 +307,22 @@ impl Message {
message_id: Snowflake, message_id: Snowflake,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<Message> { ) -> ChorusResult<Message> {
let chorus_request = ChorusRequest { let request = ChorusRequest::new(
request: Client::new() http::Method::POST,
.post(format!( format!(
"{}/channels/{}/messages/{}/crosspost", "{}/channels/{}/messages/{}/crosspost",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
channel_id, channel_id,
message_id message_id
)) )
.header("Authorization", user.token()) .as_str(),
.header("Content-Type", "application/json"), None,
limit_type: LimitType::Channel(channel_id), None,
}; None,
chorus_request.deserialize_response::<Message>(user).await Some(user),
LimitType::Channel(channel_id),
);
request.deserialize_response::<Message>(user).await
} }
/// Hides a message from the feed of the guild the channel belongs to. Returns a 204 empty response on success. /// Hides a message from the feed of the guild the channel belongs to. Returns a 204 empty response on success.
@ -328,18 +334,21 @@ impl Message {
message_id: Snowflake, message_id: Snowflake,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let chorus_request = ChorusRequest { let url = format!(
request: Client::new() "{}/channels/{}/messages/{}/hide-guild-feed",
.delete(format!( user.belongs_to.borrow().urls.api,
"{}/channels/{}/messages/{}/hide-guild-feed", channel_id,
user.belongs_to.borrow().urls.api, message_id
channel_id, );
message_id let chorus_request = ChorusRequest::new(
)) http::Method::DELETE,
.header("Authorization", user.token()) &url,
.header("Content-Type", "application/json"), None,
limit_type: LimitType::Channel(channel_id), None,
}; None,
Some(user),
LimitType::Channel(channel_id),
);
chorus_request.handle_request_as_result(user).await chorus_request.handle_request_as_result(user).await
} }
@ -359,19 +368,21 @@ impl Message {
schema: MessageModifySchema, schema: MessageModifySchema,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<Message> { ) -> ChorusResult<Message> {
let chorus_request = ChorusRequest { let url = format!(
request: Client::new() "{}/channels/{}/messages/{}",
.patch(format!( user.belongs_to.borrow().urls.api,
"{}/channels/{}/messages/{}", channel_id,
user.belongs_to.borrow().urls.api, message_id
channel_id, );
message_id let chorus_request = ChorusRequest::new(
)) http::Method::PATCH,
.header("Authorization", user.token()) &url,
.header("Content-Type", "application/json") Some(to_string(&schema).unwrap()),
.body(to_string(&schema).unwrap()), None,
limit_type: LimitType::Channel(channel_id), None,
}; Some(user),
LimitType::Channel(channel_id),
);
chorus_request.deserialize_response::<Message>(user).await chorus_request.deserialize_response::<Message>(user).await
} }
@ -383,22 +394,23 @@ impl Message {
audit_log_reason: Option<String>, audit_log_reason: Option<String>,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let mut request = Client::new() let url = format!(
.delete(format!( "{}/channels/{}/messages/{}",
"{}/channels/{}/messages/{}", user.belongs_to.borrow().urls.api,
user.belongs_to.borrow().urls.api, channel_id,
channel_id, message_id
message_id );
))
.header("Authorization", user.token()) let chorus_request = ChorusRequest::new(
.header("Content-Type", "application/json"); http::Method::DELETE,
if let Some(reason) = audit_log_reason { &url,
request = request.header("X-Audit-Log-Reason", reason); None,
} audit_log_reason.as_deref(),
let chorus_request = ChorusRequest { None,
request, Some(user),
limit_type: LimitType::Channel(channel_id), LimitType::Channel(channel_id),
}; );
chorus_request.handle_request_as_result(user).await chorus_request.handle_request_as_result(user).await
} }
@ -422,23 +434,21 @@ impl Message {
error: "`messages` must contain at least 2 entries.".to_string(), error: "`messages` must contain at least 2 entries.".to_string(),
}); });
} }
let mut request = Client::new() let request = ChorusRequest::new(
.post(format!( http::Method::POST,
format!(
"{}/channels/{}/messages/bulk-delete", "{}/channels/{}/messages/bulk-delete",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
channel_id, channel_id,
)) )
.header("Authorization", user.token()) .as_str(),
.header("Content-Type", "application/json") Some(to_string(&messages).unwrap()),
.body(to_string(&messages).unwrap()); audit_log_reason.as_deref(),
if let Some(reason) = audit_log_reason { None,
request = request.header("X-Audit-Log-Reason", reason); Some(user),
} LimitType::Channel(channel_id),
let chorus_request = ChorusRequest { );
request, request.handle_request_as_result(user).await
limit_type: LimitType::Channel(channel_id),
};
chorus_request.handle_request_as_result(user).await
} }
/// Acknowledges the currently pinned messages in a channel. Returns a 204 empty response on success. /// Acknowledges the currently pinned messages in a channel. Returns a 204 empty response on success.
@ -449,17 +459,21 @@ impl Message {
channel_id: Snowflake, channel_id: Snowflake,
user: &mut ChorusUser, user: &mut ChorusUser,
) -> ChorusResult<()> { ) -> ChorusResult<()> {
let chorus_request = ChorusRequest { let chorus_request = ChorusRequest::new(
request: Client::new() http::Method::POST,
.post(format!( format!(
"{}/channels/{}/pins/ack", "{}/channels/{}/pins/ack",
user.belongs_to.borrow().urls.api, user.belongs_to.borrow().urls.api,
channel_id, channel_id,
)) )
.header("Authorization", user.token()) .as_str(),
.header("Content-Type", "application/json"), None,
limit_type: LimitType::Channel(channel_id), None,
}; None,
Some(user),
LimitType::Channel(channel_id),
);
chorus_request.handle_request_as_result(user).await chorus_request.handle_request_as_result(user).await
} }
} }

19
src/api/channels/permissions.rs
View File

@ -74,12 +74,17 @@ impl types::Channel {
channel_id, channel_id,
overwrite_id overwrite_id
); );
let chorus_request = ChorusRequest {
request: Client::new() let request = ChorusRequest::new(
.delete(url) http::Method::DELETE,
.header("Authorization", user.token()), &url,
limit_type: LimitType::Channel(channel_id), None,
}; None,
chorus_request.handle_request_as_result(user).await None,
Some(user),
LimitType::Channel(channel_id),
);
request.handle_request_as_result(user).await
} }
} }

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

@ -1,5 +1,3 @@
use reqwest::Client;
use crate::{ use crate::{
api::LimitType, api::LimitType,
errors::ChorusResult, errors::ChorusResult,
@ -28,13 +26,18 @@ impl ReactionMeta {
self.channel_id, self.channel_id,
self.message_id self.message_id
); );
let chorus_request = ChorusRequest {
request: Client::new() let request = ChorusRequest::new(
.delete(url) http::Method::DELETE,
.header("Authorization", user.token()), &url,
limit_type: LimitType::Channel(self.channel_id), None,
}; None,
chorus_request.handle_request_as_result(user).await None,
Some(user),
LimitType::Channel(self.channel_id),
);
request.handle_request_as_result(user).await
} }
/// Gets a list of users that reacted with a specific emoji to a message. /// Gets a list of users that reacted with a specific emoji to a message.
@ -52,13 +55,18 @@ impl ReactionMeta {
self.message_id, self.message_id,
emoji emoji
); );
let chorus_request = ChorusRequest {
request: Client::new().get(url).header("Authorization", user.token()), let request = ChorusRequest::new(
limit_type: LimitType::Channel(self.channel_id), http::Method::GET,
}; &url,
chorus_request None,
.deserialize_response::<Vec<PublicUser>>(user) None,
.await None,
Some(user),
LimitType::Channel(self.channel_id),
);
request.deserialize_response::<Vec<PublicUser>>(user).await
} }
/// Deletes all the reactions for a given emoji on a message. /// Deletes all the reactions for a given emoji on a message.
@ -78,13 +86,18 @@ impl ReactionMeta {
self.message_id, self.message_id,
emoji emoji
); );
let chorus_request = ChorusRequest {
request: Client::new() let request = ChorusRequest::new(
.delete(url) http::Method::DELETE,
.header("Authorization", user.token()), &url,
limit_type: LimitType::Channel(self.channel_id), None,
}; None,
chorus_request.handle_request_as_result(user).await None,
Some(user),
LimitType::Channel(self.channel_id),
);
request.handle_request_as_result(user).await
} }
/// Create a reaction on a message. /// Create a reaction on a message.
@ -107,14 +120,18 @@ impl ReactionMeta {
self.message_id, self.message_id,
emoji emoji
); );
let chorus_request = ChorusRequest {
request: Client::new() let request = ChorusRequest::new(
.put(url) http::Method::PUT,
.header("Authorization", user.token()) &url,
.header("Content-Type", "application/json"), None,
limit_type: LimitType::Channel(self.channel_id), None,
}; None,
chorus_request.handle_request_as_result(user).await Some(user),
LimitType::Channel(self.channel_id),
);
request.handle_request_as_result(user).await
} }
/// Deletes a reaction the current user has made to the message. /// Deletes a reaction the current user has made to the message.
@ -132,13 +149,18 @@ impl ReactionMeta {
self.message_id, self.message_id,
emoji emoji
); );
let chorus_request = ChorusRequest {
request: Client::new() let request = ChorusRequest::new(
.delete(url) http::Method::DELETE,
.header("Authorization", user.token()), &url,
limit_type: LimitType::Channel(self.channel_id), None,
}; None,
chorus_request.handle_request_as_result(user).await None,
Some(user),
LimitType::Channel(self.channel_id),
);
request.handle_request_as_result(user).await
} }
/// Deletes a user's reaction to a message. /// Deletes a user's reaction to a message.
@ -164,12 +186,17 @@ impl ReactionMeta {
emoji, emoji,
user_id user_id
); );
let chorus_request = ChorusRequest {
request: Client::new() let request = ChorusRequest::new(
.delete(url) http::Method::DELETE,
.header("Authorization", user.token()), &url,
limit_type: LimitType::Channel(self.channel_id), None,
}; None,
chorus_request.handle_request_as_result(user).await None,
Some(user),
LimitType::Channel(self.channel_id),
);
request.handle_request_as_result(user).await
} }
} }

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

@ -80,9 +80,10 @@ impl Guild {
pub async fn create_channel( pub async fn create_channel(
&self, &self,
user: &mut ChorusUser, user: &mut ChorusUser,
audit_log_reason: Option<String>,
schema: ChannelCreateSchema, schema: ChannelCreateSchema,
) -> ChorusResult<Channel> { ) -> ChorusResult<Channel> {
Channel::create(user, self.id, schema).await Channel::create(user, self.id, audit_log_reason, schema).await
} }
/// Returns a list of the guild's channels. /// Returns a list of the guild's channels.
@ -197,8 +198,8 @@ impl Channel {
pub async fn create( pub async fn create(
user: &mut ChorusUser, user: &mut ChorusUser,
guild_id: Snowflake, guild_id: Snowflake,
schema: ChannelCreateSchema,
audit_log_reason: Option<String>, audit_log_reason: Option<String>,
schema: ChannelCreateSchema,
) -> ChorusResult<Channel> { ) -> ChorusResult<Channel> {
let mut request = Client::new() let mut request = Client::new()
.post(format!( .post(format!(

21
src/ratelimiter.rs
View File

@ -2,8 +2,8 @@ use std::collections::HashMap;
use log::{self, debug}; use log::{self, debug};
use reqwest::{Client, RequestBuilder, Response}; use reqwest::{Client, RequestBuilder, Response};
use serde::{Deserialize, Serialize}; use serde::Deserialize;
use serde_json::{from_str, to_string}; use serde_json::from_str;
use crate::{ use crate::{
api::{Limit, LimitType}, api::{Limit, LimitType},
@ -29,17 +29,18 @@ impl ChorusRequest {
/// * [`http::Method::DELETE`] /// * [`http::Method::DELETE`]
/// * [`http::Method::PATCH`] /// * [`http::Method::PATCH`]
/// * [`http::Method::HEAD`] /// * [`http::Method::HEAD`]
pub(crate) fn new( #[allow(unused_variables)] // TODO: Add mfa_token to request, once we figure out *how* to do so correctly
pub fn new(
method: http::Method, method: http::Method,
url: &str, url: &str,
body: Option<impl Serialize>, body: Option<String>,
audit_log_reason: Option<&str>, audit_log_reason: Option<&str>,
mfa_token: Option<&str>, mfa_token: Option<&str>,
chorus_user: Option<&mut ChorusUser>, chorus_user: Option<&mut ChorusUser>,
limit_type: LimitType, limit_type: LimitType,
) -> ChorusRequest { ) -> ChorusRequest {
let mut request = Client::new(); let request = Client::new();
let request = match method { let mut request = match method {
http::Method::GET => request.get(url), http::Method::GET => request.get(url),
http::Method::POST => request.post(url), http::Method::POST => request.post(url),
http::Method::PUT => request.put(url), http::Method::PUT => request.put(url),
@ -49,16 +50,16 @@ impl ChorusRequest {
_ => panic!("Illegal state: Method not supported."), _ => panic!("Illegal state: Method not supported."),
}; };
if let Some(user) = chorus_user { if let Some(user) = chorus_user {
let request = request.header("Authorization", user.token()); request = request.header("Authorization", user.token());
} }
if let Some(body) = body { if let Some(body) = body {
// ONCE TOLD ME THE WORLD WAS GONNA ROLL ME // ONCE TOLD ME THE WORLD WAS GONNA ROLL ME
let request = request request = request
.body(to_string(&body).unwrap()) .body(body)
.header("Content-Type", "application/json"); .header("Content-Type", "application/json");
} }
if let Some(reason) = audit_log_reason { if let Some(reason) = audit_log_reason {
let request = request.header("X-Audit-Log-Reason", reason); request = request.header("X-Audit-Log-Reason", reason);
} }
ChorusRequest { ChorusRequest {

18
tests/channels.rs
View File

@ -22,7 +22,7 @@ async fn get_channel() {
async fn delete_channel() { async fn delete_channel() {
let mut bundle = common::setup().await; let mut bundle = common::setup().await;
let channel_guard = bundle.channel.write().unwrap().clone(); let channel_guard = bundle.channel.write().unwrap().clone();
let result = Channel::delete(channel_guard, &mut bundle.user).await; let result = Channel::delete(channel_guard, None, &mut bundle.user).await;
assert!(result.is_ok()); assert!(result.is_ok());
common::teardown(bundle).await common::teardown(bundle).await
} }
@ -51,7 +51,10 @@ async fn modify_channel() {
default_thread_rate_limit_per_user: None, default_thread_rate_limit_per_user: None,
video_quality_mode: None, video_quality_mode: None,
}; };
let modified_channel = channel.modify(modify_data, &mut bundle.user).await.unwrap(); let modified_channel = channel
.modify(modify_data, None, &mut bundle.user)
.await
.unwrap();
assert_eq!(modified_channel.name, Some(CHANNEL_NAME.to_string())); assert_eq!(modified_channel.name, Some(CHANNEL_NAME.to_string()));
let permission_override = PermissionFlags::from_vec(Vec::from([ let permission_override = PermissionFlags::from_vec(Vec::from([
@ -66,9 +69,14 @@ async fn modify_channel() {
deny: "0".to_string(), deny: "0".to_string(),
}; };
let channel_id: Snowflake = bundle.channel.read().unwrap().id; let channel_id: Snowflake = bundle.channel.read().unwrap().id;
Channel::edit_permissions(&mut bundle.user, channel_id, permission_override.clone()) Channel::modify_permissions(
.await &mut bundle.user,
.unwrap(); channel_id,
None,
permission_override.clone(),
)
.await
.unwrap();
Channel::delete_permission(&mut bundle.user, channel_id, permission_override.id) Channel::delete_permission(&mut bundle.user, channel_id, permission_override.id)
.await .await

2
tests/common/mod.rs
View File

@ -93,7 +93,7 @@ pub(crate) async fn setup() -> TestBundle {
}; };
let mut user = instance.register_account(&reg).await.unwrap(); let mut user = instance.register_account(&reg).await.unwrap();
let guild = Guild::create(&mut user, guild_create_schema).await.unwrap(); let guild = Guild::create(&mut user, guild_create_schema).await.unwrap();
let channel = Channel::create(&mut user, guild.id, channel_create_schema) let channel = Channel::create(&mut user, guild.id, None, channel_create_schema)
.await .await
.unwrap(); .unwrap();

2
tests/gateway.rs
View File

@ -44,7 +44,7 @@ async fn test_self_updating_structs() {
..Default::default() ..Default::default()
}; };
received_channel received_channel
.modify(modify_schema, &mut bundle.user) .modify(modify_schema, None, &mut bundle.user)
.await .await
.unwrap(); .unwrap();
assert_eq!( assert_eq!(

4
tests/messages.rs
View File

@ -115,7 +115,7 @@ async fn test_stickies() {
.unwrap(), .unwrap(),
Vec::<Message>::new() Vec::<Message>::new()
); );
Message::sticky(channel.id, message.id, &mut bundle.user) Message::sticky(channel.id, message.id, None, &mut bundle.user)
.await .await
.unwrap(); .unwrap();
assert_eq!( assert_eq!(
@ -127,7 +127,7 @@ async fn test_stickies() {
.id, .id,
message.id message.id
); );
Message::unsticky(channel.id, message.id, &mut bundle.user) Message::unsticky(channel.id, message.id, None, &mut bundle.user)
.await .await
.unwrap(); .unwrap();
assert_eq!( assert_eq!(