pepepper/fluxer
1
0 Fork 0
mirror of https://github.com/fluxerapp/fluxer synced 2026-10-18 05:25:40 +09:00
Code Issues Packages Projects Releases Wiki Activity

chore(repo): prune dead code and duplicate abstractions (#3413)

Browse Source
This commit is contained in:
Hampus authored and GitHub committed 2026-10-12 13:09:42 +02:00
1 parent c17091768c
commit c9fdf8fead
2937 files changed
+42233 -176793
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

fluxer_admin/src/api/applications.rs
+5 -2
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use reqwest::Method;
use super::client::{AdminApiClient, ApiResult};
use super::types::{Application, ApplicationUpdateResponse, LookupApplicationResponse};
use serde::Serialize;
@@ -43,12 +45,13 @@ impl AdminApiClient {
new_owner_id: &str,
) -> ApiResult<ApplicationUpdateResponse> {
let body = TransferApplicationOwnershipRequest { new_owner_id };
self.patch_typed_with_reason(
self.send(
Method::PATCH,
&format!(
"/admin/applications/{}",
urlencoding::encode(application_id)
),
&body,
Some(&body),
None,
)
.await
fluxer_admin/src/api/bans.rs
+5 -2
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use reqwest::Method;
use crate::api::generated::types as generated_types;
use super::client::{AdminApiClient, ApiError, ApiResult};
@@ -205,9 +207,10 @@ impl AdminApiClient {
let body = generated_types::BulkBanFileShasRequest {
sha256_list: sha256_list.to_vec(),
};
self.put_typed_with_reason(
self.send(
Method::PUT,
"/admin/blocklists/file-sha/entries",
&body,
Some(&body),
audit_log_reason,
)
.await
fluxer_admin/src/api/bulk.rs
+39 -28
View File
@@ -1,5 +1,9 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::api::generated::{guild_features, user_flags};
use reqwest::Method;
use crate::api::generated::{snowflake, types as generated_types};
use super::client::{AdminApiClient, ApiError, ApiResult};
@@ -18,8 +22,13 @@ impl AdminApiClient {
remove_flags: user_flags(remove_flags)?,
user_ids: snowflakes(user_ids),
};
self.post_typed_with_reason("/admin/bulk-jobs", &body, audit_log_reason)
.await
self.send(
Method::POST,
"/admin/bulk-jobs",
Some(&body),
audit_log_reason,
)
.await
}
pub async fn bulk_update_guild_features(
@@ -34,8 +43,13 @@ impl AdminApiClient {
guild_ids: snowflakes(guild_ids),
remove_features: guild_features(remove_features),
};
self.post_typed_with_reason("/admin/bulk-jobs", &body, audit_log_reason)
.await
self.send(
Method::POST,
"/admin/bulk-jobs",
Some(&body),
audit_log_reason,
)
.await
}
pub async fn bulk_add_guild_members(
@@ -48,8 +62,13 @@ impl AdminApiClient {
guild_id: snowflake(guild_id),
user_ids: snowflakes(user_ids),
};
self.post_typed_with_reason("/admin/bulk-jobs", &body, audit_log_reason)
.await
self.send(
Method::POST,
"/admin/bulk-jobs",
Some(&body),
audit_log_reason,
)
.await
}
pub async fn bulk_delete_user_messages(
@@ -60,8 +79,13 @@ impl AdminApiClient {
let body = generated_types::AdminBulkJobCreateRequest::DeleteUserMessages {
user_ids: snowflakes(user_ids),
};
self.post_typed_with_reason("/admin/bulk-jobs", &body, audit_log_reason)
.await
self.send(
Method::POST,
"/admin/bulk-jobs",
Some(&body),
audit_log_reason,
)
.await
}
pub async fn bulk_schedule_user_deletion(
@@ -89,29 +113,16 @@ impl AdminApiClient {
.map_err(ApiError::Parse)?,
user_ids: snowflakes(user_ids),
};
self.post_typed_with_reason("/admin/bulk-jobs", &body, audit_log_reason)
.await
self.send(
Method::POST,
"/admin/bulk-jobs",
Some(&body),
audit_log_reason,
)
.await
}
}
fn snowflakes(values: &[String]) -> Vec<generated_types::SnowflakeType> {
values.iter().map(|value| snowflake(value)).collect()
}
fn user_flags(values: &[String]) -> ApiResult<Vec<generated_types::UserFlags>> {
values
.iter()
.map(|value| {
generated_types::UserFlags::try_from(value.as_str())
.map_err(|error| ApiError::Parse(error.to_string()))
})
.collect()
}
fn guild_features(values: &[String]) -> Vec<generated_types::GuildFeatureSchema> {
values
.iter()
.cloned()
.map(generated_types::GuildFeatureSchema::from)
.collect()
}
fluxer_admin/src/api/client.rs
+8 -130
View File
@@ -136,154 +136,32 @@ impl AdminApiClient {
Self::parse_response(response).await
}
pub async fn post<T: DeserializeOwned>(
pub async fn send<T, B>(
&self,
method: Method,
path: &str,
body: Option<&serde_json::Value>,
) -> ApiResult<T> {
self.post_with_reason(path, body, None).await
}
pub async fn post_typed<T, B>(&self, path: &str, body: &B) -> ApiResult<T>
where
T: DeserializeOwned,
B: Serialize + ?Sized,
{
self.post_typed_with_reason(path, body, None).await
}
pub async fn post_typed_with_reason<T, B>(
&self,
path: &str,
body: &B,
body: Option<&B>,
audit_log_reason: Option<&str>,
) -> ApiResult<T>
where
T: DeserializeOwned,
B: Serialize + ?Sized,
{
let response = self
.send_json(Method::POST, path, Some(body), audit_log_reason)
.await?;
let response = self.send_json(method, path, body, audit_log_reason).await?;
Self::parse_response(response).await
}
pub async fn post_with_reason<T: DeserializeOwned>(
pub async fn send_void<B: Serialize + ?Sized>(
&self,
method: Method,
path: &str,
body: Option<&serde_json::Value>,
audit_log_reason: Option<&str>,
) -> ApiResult<T> {
let response = self
.send_json(Method::POST, path, body, audit_log_reason)
.await?;
Self::parse_response(response).await
}
pub async fn post_void(&self, path: &str, body: Option<&serde_json::Value>) -> ApiResult<()> {
self.post_void_with_reason(path, body, None).await
}
pub async fn post_void_with_reason(
&self,
path: &str,
body: Option<&serde_json::Value>,
body: Option<&B>,
audit_log_reason: Option<&str>,
) -> ApiResult<()> {
let response = self
.send_json(Method::POST, path, body, audit_log_reason)
.await?;
let response = self.send_json(method, path, body, audit_log_reason).await?;
Self::parse_void_response(response).await
}
pub async fn patch<T: DeserializeOwned>(
&self,
path: &str,
body: Option<&serde_json::Value>,
) -> ApiResult<T> {
self.patch_with_reason(path, body, None).await
}
pub async fn patch_with_reason<T: DeserializeOwned>(
&self,
path: &str,
body: Option<&serde_json::Value>,
audit_log_reason: Option<&str>,
) -> ApiResult<T> {
let response = self
.send_json(Method::PATCH, path, body, audit_log_reason)
.await?;
Self::parse_response(response).await
}
pub async fn patch_typed_with_reason<T, B>(
&self,
path: &str,
body: &B,
audit_log_reason: Option<&str>,
) -> ApiResult<T>
where
T: DeserializeOwned,
B: Serialize + ?Sized,
{
let response = self
.send_json(Method::PATCH, path, Some(body), audit_log_reason)
.await?;
Self::parse_response(response).await
}
pub async fn put_with_reason<T: DeserializeOwned>(
&self,
path: &str,
body: Option<&serde_json::Value>,
audit_log_reason: Option<&str>,
) -> ApiResult<T> {
let response = self
.send_json(Method::PUT, path, body, audit_log_reason)
.await?;
Self::parse_response(response).await
}
pub async fn put_typed_with_reason<T, B>(
&self,
path: &str,
body: &B,
audit_log_reason: Option<&str>,
) -> ApiResult<T>
where
T: DeserializeOwned,
B: Serialize + ?Sized,
{
let response = self
.send_json(Method::PUT, path, Some(body), audit_log_reason)
.await?;
Self::parse_response(response).await
}
pub async fn delete_void_with_reason(
&self,
path: &str,
body: Option<&serde_json::Value>,
audit_log_reason: Option<&str>,
) -> ApiResult<()> {
let response = self
.send_json(Method::DELETE, path, body, audit_log_reason)
.await?;
Self::parse_void_response(response).await
}
pub async fn delete_with_reason<T: DeserializeOwned>(
&self,
path: &str,
body: Option<&serde_json::Value>,
audit_log_reason: Option<&str>,
) -> ApiResult<T> {
let response = self
.send_json(Method::DELETE, path, body, audit_log_reason)
.await?;
Self::parse_response(response).await
}
async fn parse_void_response(response: reqwest::Response) -> ApiResult<()> {
Self::check_response_status(response).await.map(drop)
}
fluxer_admin/src/api/discovery.rs
+2 -4
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::api::generated::float_to_u64;
use crate::api::generated::{snowflake, types as generated_types};
use super::client::{AdminApiClient, ApiError, ApiResult};
@@ -144,10 +146,6 @@ fn listed_guild(
})
}
fn float_to_u64(value: f64, field: &str) -> ApiResult<u64> {
crate::api::generated::number_to_u64(value, field).map_err(ApiError::Parse)
}
fn float_to_i32(value: f64, field: &str) -> ApiResult<i32> {
let parsed = crate::api::generated::number_to_u64(value, field).map_err(ApiError::Parse)?;
i32::try_from(parsed).map_err(|_| ApiError::Parse(format!("{field} is out of range: {value}")))
fluxer_admin/src/api/generated.rs
+30 -86
View File
@@ -1,5 +1,8 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use self::types as generated_types;
use crate::api::client::{ApiError, ApiResult};
use progenitor_client::{ClientHooks, ClientInfo, Error, OperationInfo};
use reqwest::header::HeaderMap;
@@ -61,94 +64,35 @@ pub(crate) fn deletion_reason_code(
.map_err(|_| format!("{field} is not a deletion reason code: {value}"))
}
pub(crate) fn user_flags(values: &[String]) -> ApiResult<Vec<generated_types::UserFlags>> {
values
.iter()
.map(|value| {
generated_types::UserFlags::try_from(value.as_str())
.map_err(|error| ApiError::Parse(error.to_string()))
})
.collect()
}
pub(crate) fn guild_features(values: &[String]) -> Vec<generated_types::GuildFeatureSchema> {
values
.iter()
.cloned()
.map(generated_types::GuildFeatureSchema::from)
.collect()
}
pub(crate) fn bool_param(value: bool) -> &'static str {
if value { "true" } else { "false" }
}
pub(crate) fn float_to_u64(value: f64, field: &str) -> ApiResult<u64> {
crate::api::generated::number_to_u64(value, field).map_err(ApiError::Parse)
}
#[cfg(test)]
mod tests {
use super::{number_to_u64, types::*};
#[test]
fn deserialize_admin_users_me() {
let json = serde_json::json!({
"user": {
"id": "123456789012345678",
"username": "testadmin",
"discriminator": 1,
"global_name": "Test Admin",
"bot": false,
"system": false,
"flags": "131141",
"premium_flags": 0,
"avatar": "abc123def456",
"banner": null,
"bio": "Hello world",
"pronouns": null,
"accent_color": null,
"email": "[email protected]",
"email_verified": true,
"email_bounced": false,
"date_of_birth": "2000-01-15",
"locale": "en-US",
"premium_type": 2,
"premium_since": "2024-01-01T00:00:00.000Z",
"premium_until": null,
"premium_grace_ends_at": null,
"premium_lifetime_sequence": null,
"temp_banned_until": null,
"pending_deletion_at": null,
"pending_bulk_message_deletion_at": null,
"deletion_reason_code": null,
"deletion_public_reason": null,
"acls": ["MANAGE_USERS", "VIEW_AUDIT_LOG"],
"traits": ["STAFF"],
"has_totp": true,
"authenticator_types": [0],
"last_active_at": "2026-05-26T12:00:00.000Z",
"last_active_ip": "203.0.113.1",
"last_active_ip_reverse": "1.113.0.203.in-addr.arpa",
"last_active_location": "New York, US"
}
});
let response: AdminUsersMeResponse =
serde_json::from_value(json).expect("failed to deserialize AdminUsersMeResponse");
assert_eq!(response.user.id.to_string(), "123456789012345678");
assert_eq!(response.user.username, "testadmin");
assert!(!response.user.bot);
assert!(response.user.email_verified);
assert_eq!(response.user.acls.len(), 2);
assert_eq!(response.user.global_name, Some("Test Admin".to_string()));
assert!(response.user.banner.is_none());
assert!(response.user.has_totp);
}
#[test]
fn deserialize_search_guilds_response() {
let json = serde_json::json!({
"guilds": [
{
"id": "987654321098765432",
"name": "Test Guild",
"icon": "def456abc123",
"banner": null,
"owner_id": "123456789012345678",
"owner_username": "guildowner",
"owner_global_name": "Guild Owner",
"owner_discriminator": "0001",
"member_count": 42,
"features": ["COMMUNITY", "NEWS"]
}
],
"total": 1
});
let response: SearchGuildsResponse =
serde_json::from_value(json).expect("failed to deserialize SearchGuildsResponse");
assert_eq!(response.total, 1.0);
assert_eq!(response.guilds.len(), 1);
assert_eq!(response.guilds[0].name, "Test Guild");
assert_eq!(*response.guilds[0].member_count, 42);
}
use super::number_to_u64;
#[test]
fn reject_lossy_generated_number_count() {
fluxer_admin/src/api/guilds.rs
+23 -67
View File
@@ -1,14 +1,17 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::api::generated::guild_features;
use reqwest::Method;
use crate::api::generated::{snowflake, types as generated_types};
use serde::Deserialize;
use super::client::{AdminApiClient, ApiError, ApiResult};
use super::reports::SearchReportsParams;
use super::types::{
GuildAuditLogResponse, GuildDetailInfo, GuildInfo, GuildUpdateResponse,
ListGuildMembersResponse, LookupGuildResponse, SearchGuildsResponse, SearchReportsResponse,
SuccessResponse,
GuildAuditLogResponse, GuildDetailInfo, GuildInfo, ListGuildMembersResponse,
LookupGuildResponse, SearchGuildsResponse, SearchReportsResponse, SuccessResponse,
};
impl AdminApiClient {
@@ -53,18 +56,17 @@ impl AdminApiClient {
guild_id: &str,
add_features: &[String],
remove_features: &[String],
) -> ApiResult<GuildUpdateResponse> {
) -> ApiResult<()> {
let body = generated_types::UpdateGuildRequest {
add_features: guild_features(add_features),
remove_features: guild_features(remove_features),
..Default::default()
};
let response = self
.generated()
self.generated()
.update_admin_guild(&snowflake(guild_id), &body)
.await
.map_err(|e| self.generated_error(e))?;
self.generated_value(response.into_inner())
Ok(())
}
pub async fn delete_guild(&self, guild_id: &str) -> ApiResult<SuccessResponse> {
@@ -80,17 +82,16 @@ impl AdminApiClient {
&self,
guild_id: &str,
new_owner_id: &str,
) -> ApiResult<GuildUpdateResponse> {
) -> ApiResult<()> {
let body = generated_types::UpdateGuildRequest {
new_owner_id: Some(snowflake(new_owner_id)),
..Default::default()
};
let response = self
.generated()
self.generated()
.update_admin_guild(&snowflake(guild_id), &body)
.await
.map_err(|e| self.generated_error(e))?;
self.generated_value(response.into_inner())
Ok(())
}
pub async fn list_guild_members(
@@ -177,44 +178,37 @@ impl AdminApiClient {
&self,
guild_id: &str,
settings: &serde_json::Value,
) -> ApiResult<GuildUpdateResponse> {
) -> ApiResult<()> {
let body = guild_settings_request(settings)?;
let response = self
.generated()
self.generated()
.update_admin_guild(&snowflake(guild_id), &body)
.await
.map_err(|e| self.generated_error(e))?;
guild_update_response(response.into_inner())
Ok(())
}
pub async fn update_guild_name(
&self,
guild_id: &str,
name: &str,
) -> ApiResult<GuildUpdateResponse> {
pub async fn update_guild_name(&self, guild_id: &str, name: &str) -> ApiResult<()> {
let body = generated_types::UpdateGuildRequest {
name: Some(name.to_owned()),
..Default::default()
};
let response = self
.generated()
self.generated()
.update_admin_guild(&snowflake(guild_id), &body)
.await
.map_err(|e| self.generated_error(e))?;
self.generated_value(response.into_inner())
Ok(())
}
pub async fn update_guild_vanity(
&self,
guild_id: &str,
vanity: Option<&str>,
) -> ApiResult<GuildUpdateResponse> {
pub async fn update_guild_vanity(&self, guild_id: &str, vanity: Option<&str>) -> ApiResult<()> {
let body = serde_json::json!({"vanity_url_code": vanity});
self.patch(
self.send::<serde::de::IgnoredAny, _>(
Method::PATCH,
&format!("/admin/guilds/{}", urlencoding::encode(guild_id)),
Some(&body),
None,
)
.await
.map(drop)
}
pub async fn reload_guild(&self, guild_id: &str) -> ApiResult<SuccessResponse> {
@@ -316,36 +310,6 @@ fn guild_admin_response(response: generated_types::GuildAdminResponse) -> ApiRes
})
}
fn guild_update_response(
response: generated_types::GuildUpdateResponse,
) -> ApiResult<GuildUpdateResponse> {
let guild = response.guild;
Ok(GuildUpdateResponse {
guild: GuildInfo {
id: String::from(guild.id),
name: String::from(guild.name),
icon: guild.icon.map(String::from),
banner: guild.banner.map(String::from),
owner_id: String::from(guild.owner_id),
owner_username: None,
owner_global_name: None,
owner_discriminator: None,
member_count: crate::api::generated::i64_to_u64(
i64::from(i32::from(guild.member_count)),
"member_count",
)
.map_err(ApiError::Parse)?,
features: guild.features.into_iter().map(String::from).collect(),
nsfw_level: guild.nsfw_level.map(i32::from),
nsfw: None,
content_warning_level: None,
content_warning_text: None,
description: None,
vanity_url_code: None,
},
})
}
fn guild_settings_request(
settings: &serde_json::Value,
) -> ApiResult<generated_types::UpdateGuildRequest> {
@@ -365,14 +329,6 @@ fn guild_settings_request(
})
}
fn guild_features(values: &[String]) -> Vec<generated_types::GuildFeatureSchema> {
values
.iter()
.cloned()
.map(generated_types::GuildFeatureSchema::from)
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
fluxer_admin/src/api/instance_config.rs
+22 -8
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use reqwest::Method;
use super::client::{AdminApiClient, ApiResult};
use super::types::{
AccountIdentitySettings, CreateRegistrationUrlRequest, CreateRegistrationUrlResponse,
@@ -30,32 +32,43 @@ impl AdminApiClient {
&self,
update: &InstanceConfigUpdateRequest,
) -> ApiResult<InstanceConfigResponse> {
self.patch_typed_with_reason("/admin/instance/config", update, None)
self.send(Method::PATCH, "/admin/instance/config", Some(update), None)
.await
}
pub async fn test_saved_instance_smtp_config(
&self,
) -> ApiResult<InstanceEmailSmtpTestResponse> {
self.post_typed("/admin/instance/config/smtp-tests", &serde_json::json!({}))
.await
self.send(
Method::POST,
"/admin/instance/config/smtp-tests",
Some(&serde_json::json!({})),
None,
)
.await
}
pub async fn create_registration_url(
&self,
request: &CreateRegistrationUrlRequest,
) -> ApiResult<CreateRegistrationUrlResponse> {
self.post_typed("/admin/instance/registration-urls", request)
.await
self.send(
Method::POST,
"/admin/instance/registration-urls",
Some(request),
None,
)
.await
}
pub async fn revoke_registration_url(&self, id: &str) -> ApiResult<InstanceConfigResponse> {
self.delete_with_reason(
self.send(
Method::DELETE,
&format!(
"/admin/instance/registration-urls/{}",
urlencoding::encode(id)
),
None,
None::<&serde_json::Value>,
None,
)
.await
@@ -81,7 +94,8 @@ impl AdminApiClient {
status: &str,
) -> ApiResult<InstanceConfigResponse> {
let body = serde_json::json!({"status": status});
self.patch_with_reason(
self.send(
Method::PATCH,
&format!(
"/admin/instance/pending-registrations/{}",
urlencoding::encode(user_id)
fluxer_admin/src/api/jobs.rs
+5 -2
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use reqwest::Method;
use crate::api::generated::snowflake;
use super::client::{AdminApiClient, ApiResult};
@@ -52,9 +54,10 @@ impl AdminApiClient {
job_id: &str,
audit_log_reason: Option<&str>,
) -> ApiResult<CancelJobResponse> {
self.put_with_reason(
self.send(
Method::PUT,
&format!("/admin/jobs/{}/cancellation", urlencoding::encode(job_id)),
None,
None::<&serde_json::Value>,
audit_log_reason,
)
.await
fluxer_admin/src/api/limit_config.rs
+3 -1
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use reqwest::Method;
use super::client::{AdminApiClient, ApiResult};
use super::types::{LimitConfigResponse, LimitConfigUpdateRequest};
@@ -12,7 +14,7 @@ impl AdminApiClient {
&self,
request: &LimitConfigUpdateRequest,
) -> ApiResult<LimitConfigResponse> {
self.put_typed_with_reason("/admin/limit-config", request, None)
self.send(Method::PUT, "/admin/limit-config", Some(request), None)
.await
}
}
fluxer_admin/src/api/messages.rs
+5 -2
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use reqwest::Method;
use crate::api::generated::{snowflake, types as generated_types};
use super::client::{AdminApiClient, ApiError, ApiResult};
@@ -16,13 +18,14 @@ impl AdminApiClient {
audit_log_reason: Option<&str>,
) -> ApiResult<()> {
let _: serde_json::Value = self
.delete_with_reason(
.send(
Method::DELETE,
&format!(
"/admin/channels/{}/messages/{}",
urlencoding::encode(channel_id),
urlencoding::encode(message_id)
),
None,
None::<&serde_json::Value>,
audit_log_reason,
)
.await?;
fluxer_admin/src/api/reports.rs
+9 -4
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use reqwest::Method;
use crate::api::generated::{snowflake, types::UpdateReportRequestResolution};
use super::client::{AdminApiClient, ApiError, ApiResult};
@@ -51,7 +53,8 @@ impl AdminApiClient {
body["public_comment"] = serde_json::Value::from(public_comment);
}
body["notify_reporter"] = serde_json::Value::from(notify_reporter);
self.patch_with_reason(
self.send(
Method::PATCH,
&format!("/admin/reports/{}", urlencoding::encode(report_id)),
Some(&body),
audit_log_reason,
@@ -69,7 +72,8 @@ impl AdminApiClient {
"legal_hold_until": legal_hold_until,
"legal_hold_reason": legal_hold_until.and(legal_hold_reason),
});
self.post_with_reason(
self.send(
Method::POST,
&format!(
"/admin/reports/{}/legal-hold",
urlencoding::encode(report_id)
@@ -85,9 +89,10 @@ impl AdminApiClient {
report_id: &str,
audit_log_reason: Option<&str>,
) -> ApiResult<()> {
self.delete_void_with_reason(
self.send_void(
Method::DELETE,
&format!("/admin/reports/{}", urlencoding::encode(report_id)),
None,
None::<&serde_json::Value>,
audit_log_reason,
)
.await
fluxer_admin/src/api/search.rs
+2 -4
View File
@@ -1,5 +1,7 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::api::generated::float_to_u64;
use crate::api::generated::{snowflake, types as generated_types};
use super::client::{AdminApiClient, ApiError, ApiResult};
@@ -74,10 +76,6 @@ fn index_refresh_status(
}
}
fn float_to_u64(value: f64, field: &str) -> ApiResult<u64> {
crate::api::generated::number_to_u64(value, field).map_err(ApiError::Parse)
}
#[cfg(test)]
mod tests {
use super::*;
fluxer_admin/src/api/types/common.rs
-5
View File
@@ -61,11 +61,6 @@ pub struct LookupGuildResponse {
pub guild: Option<GuildDetailInfo>,
}
#[derive(Clone, Debug, Deserialize)]
pub struct GuildUpdateResponse {
pub guild: GuildInfo,
}
#[derive(Clone, Debug, Deserialize)]
pub struct ListUserGuildsResponse {
pub guilds: Vec<GuildInfo>,
fluxer_admin/src/api/users.rs
+12 -18
View File
@@ -1,5 +1,9 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::api::generated::{bool_param, user_flags};
use reqwest::Method;
use crate::api::generated::{snowflake, types as generated_types};
use super::client::{AdminApiClient, ApiError, ApiResult};
@@ -367,9 +371,10 @@ impl AdminApiClient {
reason: reason.map(std::borrow::ToOwned::to_owned),
};
let resp: UserMutationResponse = self
.put_typed_with_reason(
.send(
Method::PUT,
&format!("/admin/users/{}/ban", urlencoding::encode(user_id)),
&body,
Some(&body),
private_reason,
)
.await?;
@@ -439,7 +444,8 @@ impl AdminApiClient {
"notify_user": notify_user,
});
let resp: UserMutationResponse = self
.delete_with_reason(
.send(
Method::DELETE,
&format!("/admin/users/{}/deletion", urlencoding::encode(user_id)),
Some(&body),
audit_log_reason,
@@ -458,9 +464,11 @@ impl AdminApiClient {
"ban_audit_log_id": ban_audit_log_id,
"note": note,
});
self.post_void(
self.send_void(
Method::POST,
&format!("/admin/users/{}/ban/notes", urlencoding::encode(user_id)),
Some(&body),
None,
)
.await
}
@@ -589,20 +597,6 @@ fn nonempty(value: Option<&str>) -> Option<&str> {
value.filter(|value| !value.is_empty())
}
fn bool_param(value: bool) -> &'static str {
if value { "true" } else { "false" }
}
fn user_flags(values: &[String]) -> ApiResult<Vec<generated_types::UserFlags>> {
values
.iter()
.map(|value| {
generated_types::UserFlags::try_from(value.as_str())
.map_err(|error| ApiError::Parse(error.to_string()))
})
.collect()
}
fn premium_flags(values: &[i32]) -> Vec<generated_types::PremiumFlags> {
values
.iter()
fluxer_admin/src/api/voice.rs
+8 -6
View File
@@ -1,5 +1,9 @@
// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::api::generated::bool_param;
use reqwest::Method;
use crate::api::generated::types as generated_types;
use super::client::{AdminApiClient, ApiError, ApiResult};
@@ -57,7 +61,8 @@ impl AdminApiClient {
let region_id = required_field(params, "id")?;
let body = voice_request_body(params, &["id"])?;
validate_against::<generated_types::UpdateVoiceRegionRequestBody>(&body)?;
self.patch_with_reason(
self.send(
Method::PATCH,
&format!("/admin/voice/regions/{}", urlencoding::encode(&region_id)),
Some(&body),
None,
@@ -110,7 +115,8 @@ impl AdminApiClient {
paired_coordinates(params)?;
let body = voice_request_body(params, &["region_id", "server_id"])?;
validate_against::<generated_types::UpdateVoiceServerRequestBody>(&body)?;
self.patch_with_reason(
self.send(
Method::PATCH,
&format!(
"/admin/voice/regions/{}/servers/{}",
urlencoding::encode(&region_id),
@@ -136,10 +142,6 @@ impl AdminApiClient {
}
}
fn bool_param(value: bool) -> &'static str {
if value { "true" } else { "false" }
}
fn validate_against<T: serde::de::DeserializeOwned>(params: &serde_json::Value) -> ApiResult<()> {
serde_json::from_value::<T>(params.clone())
.map(drop)