Struct ReqwestResponseEvent 

pub struct ReqwestResponseEvent { /* private fields */ }

the resulting data from a finished request is found here

Implementations

impl ReqwestResponseEvent

pub fn body(&self) -> &Bytes

retrieve a reference to the body of the response

pub fn as_str(&self) -> Result<&str>

try to get the body of the response as_str

Examples found in repository

examples/post.rs (line 27)

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 (line 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,
        // 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 as_string(&self) -> Result<String>

try to get the body of the response as an owned string

pub fn deserialize_json<'de, T: Deserialize<'de>>(&'de self) -> Result<T>

try to deserialize the body of the response using json

pub fn status(&self) -> StatusCode

Get the StatusCode of this Response.

Examples found in repository

examples/minimal.rs (line 29)

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 response_headers(&self) -> &HeaderMap

Get the Headers of this Response.

Trait Implementations

impl Clone for ReqwestResponseEvent

fn clone(&self) -> ReqwestResponseEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ReqwestResponseEvent

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

Formats the value using the given formatter.

impl EntityEvent for ReqwestResponseEvent

where Self: Send + Sync + 'static,

fn event_target(&self) -> Entity

The Entity “target” of this EntityEvent. When triggered, this will run observers that watch for this specific entity.

fn event_target_mut(&mut self) -> &mut Entity

Returns a mutable reference to the Entity “target” of this EntityEvent. When triggered, this will run observers that watch for this specific entity.

impl Event for ReqwestResponseEvent

where Self: Send + Sync + 'static,

type Trigger<'a> = EntityTrigger

Defines which observers will run, what data will be passed to them, and the order they will be run in. See Trigger for more info.