Struct BevyReqwestBuilder 

pub struct BevyReqwestBuilder<'a>(/* private fields */);

Wrapper around EntityCommands to create the on_response and on_error

Implementations

impl<'a> BevyReqwestBuilder<'a>

pub fn on_response<RB: Bundle, RM, OR: IntoObserverSystem<ReqwestResponseEvent, RB, RM>>( self, onresponse: OR, ) -> Self

Provide a system where the first argument is Trigger ReqwestResponseEvent that will run on the response from the http request

Examples

use bevy::prelude::Trigger;
use bevy_mod_reqwest::ReqwestResponseEvent;
|trigger: Trigger<ReqwestResponseEvent>|  {
  bevy::log::info!("response: {:?}", trigger.event());
};

Examples found in repository

examples/post.rs (lines 25-29)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://jsonplaceholder.typicode.com/posts";
    let body = Post {
        title: "hello".into(),
        body: "world".into(),
        user_id: 1,
    };
    let req = client.post(url).json(&body).build().unwrap();
    client
        .send(req)
        .on_response(|req: On<ReqwestResponseEvent>| {
            let req = req.event();
            let res = req.as_str();
            bevy::log::info!("return data: {res:?}");
        });
}

examples/minimal.rs (lines 25-36)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://bored-api.appbrewery.com/random";

    // use regular reqwest http calls, then poll them to completion.
    let reqwest_request = client.get(url).build().unwrap();

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem,
        // where the only requirement is that the first parameter in the system is the specific Trigger type
        // the rest is the same as a regular system
        .on_response(
            |trigger: On<ReqwestResponseEvent>, mut history: ResMut<History>| {
                let response = trigger.event();
                let data = response.as_str();
                let status = response.status();
                // let headers = req.response_headers();
                bevy::log::info!("code: {status}, data: {data:?}");
                if let Ok(data) = data {
                    history.responses.push(format!("OK: {data}"));
                }
            },
        )
        // In case of request error, it can be reached using an observersystem as well
        .on_error(
            |trigger: On<ReqwestErrorEvent>, mut history: ResMut<History>| {
                let e = &trigger.event().entity;
                bevy::log::info!("error: {e:?}");
                history.responses.push(format!("ERROR: {e:?}"));
            },
        );
}

pub fn on_json_response<T: Sync + Send + DeserializeOwned + 'static, RB: Bundle, RM, OR: IntoObserverSystem<JsonResponse<T>, RB, RM>>( self, onresponse: OR, ) -> Self

Provide a system where the first argument is Trigger JsonResponse that will run on the response from the http request, skipping some boilerplate of having to manually doing the JSON parsing

Examples

use bevy::prelude::Trigger;
use bevy_mod_reqwest::JsonResponse;
|trigger: Trigger<JsonResponse<T>>|  {
  bevy::log::info!("response: {:?}", trigger.event());
};

Examples found in repository

examples/json.rs (lines 24-28)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://bored-api.appbrewery.com/random";

    // use regular reqwest http calls, then poll them to completion.
    let reqwest_request = client.get(url).build().unwrap();

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem
        .on_json_response(|trigger: On<JsonResponse<Bored>>| {
            let data: &Bored = &trigger.event().data;
            // let headers = req.response_headers();
            bevy::log::info!("data: {data:?}");
        })
        // In case of request error, it can be reached using an observersystem
        .on_error(|trigger: On<ReqwestErrorEvent>| {
            let e = &trigger.event().error;
            bevy::log::info!("error: {e:?}");
        });
}

pub fn on_error<EB: Bundle, EM, OE: IntoObserverSystem<ReqwestErrorEvent, EB, EM>>( self, onerror: OE, ) -> Self

Provide a system where the first argument is Trigger ReqwestErrorEvent that will run on the response from the http request

Examples

use bevy::prelude::Trigger;
use bevy_mod_reqwest::ReqwestErrorEvent;
|trigger: Trigger<ReqwestErrorEvent>|  {
  bevy::log::info!("response: {:?}", trigger.event());
};

Examples found in repository

examples/json.rs (lines 30-33)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://bored-api.appbrewery.com/random";

    // use regular reqwest http calls, then poll them to completion.
    let reqwest_request = client.get(url).build().unwrap();

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem
        .on_json_response(|trigger: On<JsonResponse<Bored>>| {
            let data: &Bored = &trigger.event().data;
            // let headers = req.response_headers();
            bevy::log::info!("data: {data:?}");
        })
        // In case of request error, it can be reached using an observersystem
        .on_error(|trigger: On<ReqwestErrorEvent>| {
            let e = &trigger.event().error;
            bevy::log::info!("error: {e:?}");
        });
}

examples/minimal.rs (lines 38-44)

fn send_requests(mut client: BevyReqwest) {
    let url = "https://bored-api.appbrewery.com/random";

    // use regular reqwest http calls, then poll them to completion.
    let reqwest_request = client.get(url).build().unwrap();

    client
        // Sends the created http request
        .send(reqwest_request)
        // The response from the http request can be reached using an observersystem,
        // where the only requirement is that the first parameter in the system is the specific Trigger type
        // the rest is the same as a regular system
        .on_response(
            |trigger: On<ReqwestResponseEvent>, mut history: ResMut<History>| {
                let response = trigger.event();
                let data = response.as_str();
                let status = response.status();
                // let headers = req.response_headers();
                bevy::log::info!("code: {status}, data: {data:?}");
                if let Ok(data) = data {
                    history.responses.push(format!("OK: {data}"));
                }
            },
        )
        // In case of request error, it can be reached using an observersystem as well
        .on_error(
            |trigger: On<ReqwestErrorEvent>, mut history: ResMut<History>| {
                let e = &trigger.event().entity;
                bevy::log::info!("error: {e:?}");
                history.responses.push(format!("ERROR: {e:?}"));
            },
        );
}