Struct actix_web_flash_messages::FlashMessagesFramework

pub struct FlashMessagesFramework { /* fields omitted */ }

actix-web middleware providing support for sending and receiving FlashMessages.

Use FlashMessagesFramework::builder to build an instance of FlashMessagesFramework!

use actix_web_flash_messages::{FlashMessagesFramework, storage::CookieMessageStore};
use actix_web::{HttpServer, App, web, cookie::Key};

#[actix_web::main]
async fn main() {
    let signing_key = Key::generate(); // This will usually come from configuration!
    let message_store = CookieMessageStore::builder(signing_key).build();
    let message_framework = FlashMessagesFramework::builder(message_store).build();

    HttpServer::new(move || {
        App::new()
            .wrap(message_framework.clone())
        // [...] your endpoints
    })
}

Implementations

impl FlashMessagesFramework

pub fn builder<S: FlashMessageStore + 'static>(
    storage_backend: S
) -> FlashMessagesFrameworkBuilder

A fluent API to configure FlashMessagesFramework.

It takes as input a message store, the only required piece of configuration.

actix-web-flash-messages provides a cookie-based implementation of flash messages, CookieMessageStore, using a signed cookie to store and retrieve messages.
You can provide your own custom message store backend by implementing the FlashMessageStore trait.

Trait Implementations

impl Clone for FlashMessagesFramework

fn clone(&self) -> FlashMessagesFramework

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S, B> Transform<S, ServiceRequest> for FlashMessagesFramework where
    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
    S::Future: 'static,
    B: MessageBody + 'static, 

type Response = ServiceResponse<B>

Responses produced by the service.

type Error = Error

Errors produced by the service.

type Transform = FlashMessagesMiddleware<S>

The TransformService value created by this factory

type InitError = ()

Errors produced while building a transform service.

type Future = Ready<Result<Self::Transform, Self::InitError>>

The future response value.

fn new_transform(&self, service: S) -> Self::Future

Creates and returns a new Transform component, asynchronously