twilight_http/request/guild/ban/
delete_ban.rs

1use crate::{
2    client::Client,
3    error::Error,
4    request::{self, AuditLogReason, Request, TryIntoRequest},
5    response::{marker::EmptyBody, Response, ResponseFuture},
6    routing::Route,
7};
8use std::future::IntoFuture;
9use twilight_model::id::{
10    marker::{GuildMarker, UserMarker},
11    Id,
12};
13use twilight_validate::request::{audit_reason as validate_audit_reason, ValidationError};
14
15/// Remove a ban from a user in a guild.
16///
17/// # Examples
18///
19/// Unban user `200` from guild `100`:
20///
21/// ```no_run
22/// use twilight_http::Client;
23/// use twilight_model::id::Id;
24///
25/// # #[tokio::main]
26/// # async fn main() -> Result<(), Box<dyn std::error::Error>> {
27/// let client = Client::new("my token".to_owned());
28///
29/// let guild_id = Id::new(100);
30/// let user_id = Id::new(200);
31///
32/// client.delete_ban(guild_id, user_id).await?;
33/// # Ok(()) }
34/// ```
35#[must_use = "requests must be configured and executed"]
36pub struct DeleteBan<'a> {
37    guild_id: Id<GuildMarker>,
38    http: &'a Client,
39    user_id: Id<UserMarker>,
40    reason: Result<Option<&'a str>, ValidationError>,
41}
42
43impl<'a> DeleteBan<'a> {
44    pub(crate) const fn new(
45        http: &'a Client,
46        guild_id: Id<GuildMarker>,
47        user_id: Id<UserMarker>,
48    ) -> Self {
49        Self {
50            guild_id,
51            http,
52            user_id,
53            reason: Ok(None),
54        }
55    }
56}
57
58impl<'a> AuditLogReason<'a> for DeleteBan<'a> {
59    fn reason(mut self, reason: &'a str) -> Self {
60        self.reason = validate_audit_reason(reason).and(Ok(Some(reason)));
61
62        self
63    }
64}
65
66impl IntoFuture for DeleteBan<'_> {
67    type Output = Result<Response<EmptyBody>, Error>;
68
69    type IntoFuture = ResponseFuture<EmptyBody>;
70
71    fn into_future(self) -> Self::IntoFuture {
72        let http = self.http;
73
74        match self.try_into_request() {
75            Ok(request) => http.request(request),
76            Err(source) => ResponseFuture::error(source),
77        }
78    }
79}
80
81impl TryIntoRequest for DeleteBan<'_> {
82    fn try_into_request(self) -> Result<Request, Error> {
83        let mut request = Request::builder(&Route::DeleteBan {
84            guild_id: self.guild_id.get(),
85            user_id: self.user_id.get(),
86        });
87
88        if let Some(reason) = self.reason.map_err(Error::validation)? {
89            request = request.headers(request::audit_header(reason)?);
90        }
91
92        request.build()
93    }
94}