Struct yew::services::fetch::FetchService

pub struct FetchService {}

A service to fetch resources.

Methods

impl FetchService

pub fn new() -> Self

Creates a new service instance connected to App by provided sender.

pub fn fetch<IN, OUT: 'static>(
    &mut self,
    request: Request<IN>,
    callback: Callback<Response<OUT>>
) -> FetchTask where
    IN: Into<Text>,
    OUT: From<Text>, 

Sends a request to a remote server given a Request object and a callback fuction to convert a Response object into a loop's message.

You may use a Request builder to build your request declaratively as on the following examples:

   let post_request = Request::post("https://my.api/v1/resource")
           .header("Content-Type", "application/json")
           .body(Json(&json!({"foo": "bar"})))
           .expect("Failed to build request.");

   let get_request = Request::get("https://my.api/v1/resource")
           .body(Nothing)
           .expect("Failed to build request.");

The callback function can build a loop message by passing or analizing the response body and metadata.

    context.web.fetch(
        post_request,
        |response| {
            if response.status().is_success() {
                Msg::Noop
            } else {
                Msg::Error
            }
        }
    )

One can also simply consume and pass the response or body object into the message.

    context.web.fetch(
        get_request,
        |response| {
            let (meta, Json(body)) = response.into_parts();
            if meta.status.is_success() {
                Msg::FetchResourceComplete(body)
            } else {
                Msg::FetchResourceFailed
            }
        }
    )

pub fn fetch_with_options<IN, OUT: 'static>(
    &mut self,
    request: Request<IN>,
    options: FetchOptions,
    callback: Callback<Response<OUT>>
) -> FetchTask where
    IN: Into<Text>,
    OUT: From<Text>, 

fetch with provided FetchOptions object. Use it if you need to send cookies with a request:

    let request = fetch::Request::get("/path/")
        .body(Nothing).unwrap();
    let options = FetchOptions {
        credentials: Some(Credentials::SameOrigin),
        ..FetchOptions::default()
    };
    let task = fetch_service.fetch_with_options(request, options, callback);

pub fn fetch_binary<IN, OUT: 'static>(
    &mut self,
    request: Request<IN>,
    callback: Callback<Response<OUT>>
) -> FetchTask where
    IN: Into<Binary>,
    OUT: From<Binary>, 

Fetch the data in binary format.

pub fn fetch_binary_with_options<IN, OUT: 'static>(
    &mut self,
    request: Request<IN>,
    options: FetchOptions,
    callback: Callback<Response<OUT>>
) -> FetchTask where
    IN: Into<Binary>,
    OUT: From<Binary>, 

Fetch the data in binary format.

Trait Implementations

impl Default for FetchService

fn default() -> FetchService

Returns the "default value" for a type.