Skip to content

A free and open source instant messaging and VoIP chat app built for friends, groups, and communities.

TypeScript fluxerfluxerapp
11.4 KB
Raw Blame
// 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, ListGuildMembersResponse,
    LookupGuildResponse, SearchGuildsResponse, SearchReportsResponse, SuccessResponse,
};

impl AdminApiClient {
    pub async fn search_guilds(
        &self,
        query: &str,
        limit: u32,
        offset: u64,
    ) -> ApiResult<SearchGuildsResponse> {
        let limit = limit.to_string();
        let offset = offset.to_string();
        let response = self
            .generated()
            .list_admin_guilds(Some(limit.as_str()), Some(offset.as_str()), Some(query))
            .await
            .map_err(|e| self.generated_error(e))?;
        search_guilds_response(response.into_inner())
    }

    pub async fn get_guild_by_id(&self, guild_id: &str) -> ApiResult<GuildInfo> {
        self.lookup_guild(guild_id)
            .await?
            .map(GuildInfo::from)
            .ok_or_else(|| ApiError::http(404, "Guild not found"))
    }

    pub async fn lookup_guild(&self, guild_id: &str) -> ApiResult<Option<GuildDetailInfo>> {
        let response = self
            .generated()
            .get_admin_guild(&snowflake(guild_id))
            .await
            .map_err(|e| self.generated_error(e))?;
        let resp: LookupGuildResponse = self.generated_value(response.into_inner())?;
        Ok(resp.guild)
    }

    pub async fn update_guild_features(
        &self,
        guild_id: &str,
        add_features: &[String],
        remove_features: &[String],
    ) -> ApiResult<()> {
        let body = generated_types::UpdateGuildRequest {
            add_features: guild_features(add_features),
            remove_features: guild_features(remove_features),
            ..Default::default()
        };
        self.generated()
            .update_admin_guild(&snowflake(guild_id), &body)
            .await
            .map_err(|e| self.generated_error(e))?;
        Ok(())
    }

    pub async fn delete_guild(
        &self,
        guild_id: &str,
        basis: generated_types::CommunityRemovalBasis,
        internal_note: Option<&str>,
    ) -> ApiResult<SuccessResponse> {
        let body = generated_types::AdminGuildDeleteRequest { basis };
        self.send(
            Method::DELETE,
            &format!("/admin/guilds/{}", urlencoding::encode(guild_id)),
            Some(&body),
            internal_note,
        )
        .await
    }

    pub async fn transfer_guild_ownership(
        &self,
        guild_id: &str,
        new_owner_id: &str,
    ) -> ApiResult<()> {
        let body = generated_types::UpdateGuildRequest {
            new_owner_id: Some(snowflake(new_owner_id)),
            ..Default::default()
        };
        self.generated()
            .update_admin_guild(&snowflake(guild_id), &body)
            .await
            .map_err(|e| self.generated_error(e))?;
        Ok(())
    }

    pub async fn list_guild_members(
        &self,
        guild_id: &str,
        limit: u32,
        offset: u64,
    ) -> ApiResult<ListGuildMembersResponse> {
        let limit = limit.to_string();
        let offset = offset.to_string();
        let response = self
            .generated()
            .list_admin_guild_members(
                &snowflake(guild_id),
                Some(limit.as_str()),
                Some(offset.as_str()),
            )
            .await
            .map_err(|e| self.generated_error(e))?;
        self.generated_value(response.into_inner())
    }

    pub async fn ban_guild_member(&self, guild_id: &str, user_id: &str) -> ApiResult<()> {
        let body = generated_types::BanGuildMemberBody::default();
        self.generated()
            .ban_admin_guild_member(&snowflake(guild_id), &snowflake(user_id), &body)
            .await
            .map_err(|e| self.generated_error(e))?;
        Ok(())
    }

    pub async fn kick_guild_member(&self, guild_id: &str, user_id: &str) -> ApiResult<()> {
        self.generated()
            .kick_admin_guild_member(&snowflake(guild_id), &snowflake(user_id))
            .await
            .map_err(|e| self.generated_error(e))?;
        Ok(())
    }

    pub async fn list_guild_audit_logs(
        &self,
        guild_id: &str,
        limit: Option<u32>,
        before: Option<&str>,
    ) -> ApiResult<GuildAuditLogResponse> {
        let before = before.map(snowflake);
        let limit = limit
            .map(i32::try_from)
            .transpose()
            .map_err(|e| ApiError::Parse(e.to_string()))?;
        let response = self
            .generated()
            .list_admin_guild_audit_logs(
                &snowflake(guild_id),
                None,
                None,
                before.as_ref(),
                limit,
                None,
            )
            .await
            .map_err(|e| self.generated_error(e))?;
        self.generated_value(response.into_inner())
    }

    pub async fn clear_guild_fields(&self, guild_id: &str, fields: &[String]) -> ApiResult<()> {
        let fields = fields
            .iter()
            .map(|field| generated_types::UpdateGuildRequestFieldsItem::try_from(field.as_str()))
            .collect::<Result<Vec<_>, _>>()
            .map_err(|e| ApiError::Parse(e.to_string()))?;
        let body = generated_types::UpdateGuildRequest {
            fields,
            ..Default::default()
        };
        self.generated()
            .update_admin_guild(&snowflake(guild_id), &body)
            .await
            .map_err(|e| self.generated_error(e))?;
        Ok(())
    }

    pub async fn clear_guild_role_icon(&self, guild_id: &str, role_id: &str) -> ApiResult<()> {
        self.generated()
            .clear_admin_guild_role_icon(&snowflake(guild_id), &snowflake(role_id))
            .await
            .map_err(|e| self.generated_error(e))?;
        Ok(())
    }

    pub async fn update_guild_settings(
        &self,
        guild_id: &str,
        settings: &serde_json::Value,
    ) -> ApiResult<()> {
        let body = guild_settings_request(settings)?;
        self.generated()
            .update_admin_guild(&snowflake(guild_id), &body)
            .await
            .map_err(|e| self.generated_error(e))?;
        Ok(())
    }

    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()
        };
        self.generated()
            .update_admin_guild(&snowflake(guild_id), &body)
            .await
            .map_err(|e| self.generated_error(e))?;
        Ok(())
    }

    pub async fn update_guild_vanity(&self, guild_id: &str, vanity: Option<&str>) -> ApiResult<()> {
        let body = serde_json::json!({"vanity_url_code": vanity});
        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> {
        let response = self
            .generated()
            .create_admin_guild_reload(&snowflake(guild_id))
            .await
            .map_err(|e| self.generated_error(e))?;
        self.generated_value(response.into_inner())
    }

    pub async fn shutdown_guild(&self, guild_id: &str) -> ApiResult<SuccessResponse> {
        let response = self
            .generated()
            .create_admin_guild_shutdown(&snowflake(guild_id))
            .await
            .map_err(|e| self.generated_error(e))?;
        self.generated_value(response.into_inner())
    }

    pub async fn force_add_user_to_guild(
        &self,
        user_id: &str,
        guild_id: &str,
    ) -> ApiResult<SuccessResponse> {
        let response = self
            .generated()
            .add_admin_guild_member(&snowflake(guild_id), &snowflake(user_id))
            .await
            .map_err(|e| self.generated_error(e))?;
        self.generated_value(response.into_inner())
    }

    pub async fn search_reports_by_guild(
        &self,
        guild_id: &str,
        limit: u32,
        offset: u64,
    ) -> ApiResult<SearchReportsResponse> {
        self.search_reports(&SearchReportsParams {
            reported_guild_id: Some(guild_id),
            limit,
            offset,
            ..Default::default()
        })
        .await
    }
}

#[derive(Deserialize)]
struct GuildSettingsPatch {
    content_warning_level: Option<generated_types::ContentWarningLevelInput>,
    content_warning_text: Option<String>,
    default_message_notifications: Option<generated_types::DefaultMessageNotificationsInput>,
    disabled_operations: Option<generated_types::GuildOperations>,
    explicit_content_filter: Option<generated_types::GuildExplicitContentFilterInput>,
    mfa_level: Option<generated_types::GuildMfaLevelInput>,
    nsfw: Option<bool>,
    nsfw_level: Option<generated_types::NsfwLevelInput>,
    verification_level: Option<generated_types::GuildVerificationLevelInput>,
}

fn search_guilds_response(
    response: generated_types::SearchGuildsResponse,
) -> ApiResult<SearchGuildsResponse> {
    Ok(SearchGuildsResponse {
        guilds: response
            .guilds
            .into_iter()
            .map(guild_admin_response)
            .collect::<ApiResult<Vec<_>>>()?,
        total: crate::api::generated::number_to_u64(response.total, "total")
            .map_err(ApiError::Parse)?,
    })
}

fn guild_admin_response(response: generated_types::GuildAdminResponse) -> ApiResult<GuildInfo> {
    Ok(GuildInfo {
        id: String::from(response.id),
        name: response.name,
        icon: response.icon,
        banner: response.banner,
        owner_id: String::from(response.owner_id),
        owner_username: response.owner_username,
        owner_global_name: response.owner_global_name,
        owner_discriminator: response.owner_discriminator,
        member_count: crate::api::generated::i64_to_u64(
            i64::from(i32::from(response.member_count)),
            "member_count",
        )
        .map_err(ApiError::Parse)?,
        features: response.features.into_iter().map(String::from).collect(),
        nsfw_level: response.nsfw_level.map(i32::from),
        nsfw: response.nsfw,
        content_warning_level: response.content_warning_level.map(i32::from),
        content_warning_text: response.content_warning_text.map(String::from),
        description: None,
        vanity_url_code: None,
    })
}

fn guild_settings_request(
    settings: &serde_json::Value,
) -> ApiResult<generated_types::UpdateGuildRequest> {
    let patch = serde_json::from_value::<GuildSettingsPatch>(settings.clone())
        .map_err(|e| ApiError::Parse(e.to_string()))?;
    Ok(generated_types::UpdateGuildRequest {
        content_warning_level: patch.content_warning_level,
        content_warning_text: patch.content_warning_text,
        default_message_notifications: patch.default_message_notifications,
        disabled_operations: patch.disabled_operations,
        explicit_content_filter: patch.explicit_content_filter,
        mfa_level: patch.mfa_level,
        nsfw: patch.nsfw,
        nsfw_level: patch.nsfw_level,
        verification_level: patch.verification_level,
        ..Default::default()
    })
}