Struct Token 

pub struct Token {
    pub audit_ids: Vec<String>,
    pub methods: Vec<String>,
    pub expires_at: DateTime<Utc>,
    pub issued_at: DateTime<Utc>,
    pub user: User,
    pub domain: Option<Domain>,
    pub project: Option<Project>,
    pub trust: Option<TokenTrustRepr>,
    pub roles: Option<Vec<RoleRef>>,
    pub system: Option<System>,
    pub catalog: Option<Catalog>,
}

Authorization token.

Fields

audit_ids: Vec<String>

A list of one or two audit IDs. An audit ID is a unique, randomly generated, URL-safe string that you can use to track a token. The first audit ID is the current audit ID for the token. The second audit ID is present for only re-scoped tokens and is the audit ID from the token before it was re-scoped. A re- scoped token is one that was exchanged for another token of the same or different scope. You can use these audit IDs to track the use of a token or chain of tokens across multiple requests and endpoints without exposing the token ID to non-privileged users.

methods: Vec<String>

The authentication methods, which are commonly password, token, or other methods. Indicates the accumulated set of authentication methods that were used to obtain the token. For example, if the token was obtained by password authentication, it contains password. Later, if the token is exchanged by using the token authentication method one or more times, the subsequently created tokens contain both password and token in their methods attribute. Unlike multi-factor authentication, the methods attribute merely indicates the methods that were used to authenticate the user in exchange for a token. The client is responsible for determining the total number of authentication factors.

expires_at: DateTime<Utc>

The date and time when the token expires.

issued_at: DateTime<Utc>

The date and time when the token was issued.

user: User

A user object.

domain: Option<Domain>

A domain object including the id and name representing the domain the token is scoped to. This is only included in tokens that are scoped to a domain.

project: Option<Project>

A project object including the id, name and domain object representing the project the token is scoped to. This is only included in tokens that are scoped to a project.

trust: Option<TokenTrustRepr>

A trust object.

roles: Option<Vec<RoleRef>>

A list of role objects.

system: Option<System>

A system object.

catalog: Option<Catalog>

A catalog object.

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Token

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Token

fn default() -> Token

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Token

fn deserialize<__D>( __deserializer: __D, ) -> Result<Token, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Token

fn eq(&self, other: &Token) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Token

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ToSchema for Token

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.

impl TryFrom<&Token> for Token

type Error = BuilderError

The type returned in the event of a conversion error.

fn try_from(value: &BackendToken) -> Result<Self, Self::Error>

Performs the conversion.

impl Validate for Token

fn validate(&self) -> Result<(), ValidationErrors>

impl<'v_a> ValidateArgs<'v_a> for Token

type Args = ()

fn validate_with_args( &self, args: <Token as ValidateArgs<'v_a>>::Args, ) -> Result<(), ValidationErrors>

impl StructuralPartialEq for Token