Struct poem::web::Form

pub struct Form<T>(pub T);

An extractor that can deserialize some type from query string or body.

If the method is not GET, the query parameters will be parsed from the body, otherwise it is like Query.

If the Content-Type is not application/x-www-form-urlencoded, then a Bad Request response will be returned.

Errors

• ReadBodyError
• ParseFormError

Example

use poem::{
    get, handler,
    http::{Method, StatusCode, Uri},
    web::Form,
    Endpoint, Request, Route,
};
use serde::Deserialize;

#[derive(Deserialize)]
struct CreateDocument {
    title: String,
    content: String,
}

#[handler]
fn index(Form(CreateDocument { title, content }): Form<CreateDocument>) -> String {
    format!("{}:{}", title, content)
}

let app = Route::new().at("/", get(index).post(index));

let resp = app
    .call(
        Request::builder()
            .uri(Uri::from_static("/?title=foo&content=bar"))
            .finish(),
    )
    .await
    .unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.into_body().into_string().await.unwrap(), "foo:bar");

let resp = app
    .call(
        Request::builder()
            .method(Method::POST)
            .uri(Uri::from_static("/"))
            .content_type("application/x-www-form-urlencoded")
            .body("title=foo&content=bar"),
    )
    .await
    .unwrap();
assert_eq!(resp.status(), StatusCode::OK);
assert_eq!(resp.into_body().into_string().await.unwrap(), "foo:bar");

Tuple Fields

0: T

Trait Implementations

impl<T> Deref for Form<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> DerefMut for Form<T>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'a, T: DeserializeOwned> FromRequest<'a> for Form<T>

fn from_request<'life0, 'async_trait>(
    req: &'a Request,
    body: &'life0 mut RequestBody
) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>> where
    'a: 'async_trait,
    'life0: 'async_trait,
    Self: 'async_trait, 

Extract from request head and body.

fn from_request_without_body<'async_trait>(
    req: &'a Request
) -> Pin<Box<dyn Future<Output = Result<Self>> + Send + 'async_trait>> where
    'a: 'async_trait,
    Self: Send + 'async_trait, 

Extract from request head.