Trait ntex::web::FromRequest[−][src]

pub trait FromRequest<Err>: Sized {
    type Error;
    type Future: Future<Output = Result<Self, Self::Error>>;
    fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future;

    fn extract(req: &HttpRequest) -> Self::Future { ... }
}

Expand description

Trait implemented by types that can be extracted from request.

Types that implement this trait can be used with Route handlers.

Associated Types

`type Error`[src]

The associated error which can be returned.

`type Future: Future<Output = Result<Self, Self::Error>>`[src]

Future that resolves to a Self

Required methods

`fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future`[src]

Convert request to a Self

Provided methods

`fn extract(req: &HttpRequest) -> Self::Future`[src]

Convert request to a Self

This method uses Payload::None as payload stream.

Implementations on Foreign Types

`impl<T, Err> FromRequest<Err> for Option<T> where T: FromRequest<Err> + 'static, T::Future: 'static, Err: ErrorRenderer, <T as FromRequest<Err>>::Error: Into<Err::Container>,` [src]

Optionally extract a field from the request

If the FromRequest for T fails, return None rather than returning an error response

Example

use ntex::{http, util::Ready};
use ntex::web::{self, error, App, HttpRequest, FromRequest, DefaultError};
use rand;

#[derive(Debug, serde::Deserialize)]
struct Thing {
    name: String
}

impl<Err> FromRequest<Err> for Thing {
    type Error = error::Error;
    type Future = Ready<Self, Self::Error>;

    fn from_request(req: &HttpRequest, payload: &mut http::Payload) -> Self::Future {
        if rand::random() {
            Ready::Ok(Thing { name: "thingy".into() })
        } else {
            Ready::Err(error::ErrorBadRequest("no luck").into())
        }
    }
}

/// extract `Thing` from request
async fn index(supplied_thing: Option<Thing>) -> String {
    match supplied_thing {
        // Puns not intended
        Some(thing) => format!("Got something: {:?}", thing),
        None => format!("No thing!")
    }
}

fn main() {
    let app = App::new().service(
        web::resource("/users/:first").route(
            web::post().to(index))
    );
}

`type Error = Err::Container`

`type Future = Pin<Box<dyn Future<Output = Result<Option<T>, Self::Error>>>>`

`fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future`[src]

`impl<T, E> FromRequest<E> for Result<T, T::Error> where T: FromRequest<E> + 'static, T::Error: 'static, T::Future: 'static, E: ErrorRenderer,` [src]

Optionally extract a field from the request or extract the Error if unsuccessful

If the FromRequest for T fails, inject Err into handler rather than returning an error response

Example

use ntex::{http, util::Ready};
use ntex::web::{self, error, App, HttpRequest, FromRequest};
use rand;

#[derive(Debug, serde::Deserialize)]
struct Thing {
    name: String
}

impl<Err> FromRequest<Err> for Thing {
    type Error = error::Error;
    type Future = Ready<Thing, Self::Error>;

    fn from_request(req: &HttpRequest, payload: &mut http::Payload) -> Self::Future {
        if rand::random() {
            Ready::Ok(Thing { name: "thingy".into() })
        } else {
            Ready::Err(error::ErrorBadRequest("no luck").into())
        }
    }
}

/// extract `Thing` from request
async fn index(supplied_thing: Result<Thing, error::Error>) -> String {
    match supplied_thing {
        Ok(thing) => format!("Got thing: {:?}", thing),
        Err(e) => format!("Error extracting thing: {}", e)
    }
}

fn main() {
    let app = App::new().service(
        web::resource("/users/:first").route(web::post().to(index))
    );
}