Struct twilight_http::request::guild::GetAuditLog

pub struct GetAuditLog<'a> { /* private fields */ }

Get the audit log for a guild.

Examples

use twilight_http::Client;
use twilight_model::id::Id;

let client = Client::new("token".to_owned());

let guild_id = Id::new(101);
let audit_log = client.audit_log(guild_id).await?.model().await?;

for entry in audit_log.entries {
    println!("ID: {}", entry.id);
    println!("  Action Type: {}", u16::from(entry.action_type));
    println!("  Changes:");

    for change in entry.changes {
        println!("{change:?}");
    }
}

Implementations

impl<'a> GetAuditLog<'a>

pub const fn action_type(self, action_type: AuditLogEventType) -> Self

Filter by an action type.

pub const fn after(self, after: u64) -> Self

Get audit log entries after the entry specified.

pub const fn before(self, before: u64) -> Self

Get audit log entries before the entry specified.

pub const fn limit(self, limit: u16) -> Result<Self, ValidationError>

Set the maximum number of audit logs to retrieve.

The minimum is 1 and the maximum is 100.

Errors

Returns an error of type GetGuildAuditLog if the limit is 0 or greater than 100.

pub const fn user_id(self, user_id: Id<UserMarker>) -> Self

Filter audit log for entries from a user.

This is the user who did the auditable action, not the target of the auditable action.

pub fn exec(self) -> ResponseFuture<AuditLog>

👎Deprecated since 0.14.0: use .await or into_future instead

Execute the request, returning a future resolving to a Response.

Trait Implementations

impl IntoFuture for GetAuditLog<'_>

type Output = Result<Response<AuditLog>, Error>

The output that the future will produce on completion.

type IntoFuture = ResponseFuture<AuditLog>

Which kind of future are we turning this into?

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl TryIntoRequest for GetAuditLog<'_>

fn try_into_request(self) -> Result<Request, Error>

Try to convert a request builder into a raw Request.