Struct FetchService

pub struct FetchService {}

A service to fetch resources.

Implementations

impl FetchService

pub fn fetch<IN, OUT>( request: Request<IN>, callback: Callback<Response<OUT>>, ) -> Result<FetchTask, &'static str>

where IN: Into<Text>, OUT: From<Text> + 'static,

Sends a request to a remote server given a Request object and a callback function 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 analyzing the response body and metadata.

let task = FetchService::fetch(
    post_request,
    link.callback(|response: Response<Result<String, anyhow::Error>>| {
        if response.status().is_success() {
            Msg::Noop
        } else {
            Msg::Error
        }
    }),
);

For a full example, you can specify that the response must be in the JSON format, and be a specific serialized data type. If the mesage isn’t Json, or isn’t the specified data type, then you will get a message indicating failure.

#[derive(Deserialize)]
struct Data {
   value: String
}

let get_request = Request::get("/thing").body(Nothing).unwrap();
let callback = link.callback(|response: Response<Json<Result<Data, anyhow::Error>>>| {
    if let (meta, Json(Ok(body))) = response.into_parts() {
        if meta.status.is_success() {
            return Msg::FetchResourceComplete(body);
        }
    }
    Msg::FetchResourceFailed
});

let task = FetchService::fetch(get_request, callback);

pub fn fetch_with_options<IN, OUT>( request: Request<IN>, options: FetchOptions, callback: Callback<Response<OUT>>, ) -> Result<FetchTask, &'static str>

where IN: Into<Text>, OUT: From<Text> + 'static,

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 = FetchService::fetch_with_options(request, options, callback);

pub fn fetch_binary<IN, OUT>( request: Request<IN>, callback: Callback<Response<OUT>>, ) -> Result<FetchTask, &'static str>

where IN: Into<Binary>, OUT: From<Binary> + 'static,

Fetch the data in binary format.

pub fn fetch_binary_with_options<IN, OUT>( request: Request<IN>, options: FetchOptions, callback: Callback<Response<OUT>>, ) -> Result<FetchTask, &'static str>

where IN: Into<Binary>, OUT: From<Binary> + 'static,

Fetch the data in binary format using the provided request options.

Trait Implementations

impl Debug for FetchService

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

Formats the value using the given formatter.

impl Default for FetchService

fn default() -> FetchService

Returns the “default value” for a type.