rust-wistia 0.1.1

A rust crate wrapping Wistia's Data and Upload API into a simple easy to use interface
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73

//! Utilities to validate a response to ensure that its *status code*
//! indicates that it is a success.
//!
use crate::log::error;
use crate::models::{RequestError, WistiaError};
use crate::types::Result;
use crate::utils::{host_with_path, resp_to_string};

use core::result::Result::{Err, Ok};

use http::Response;
use hyper::{http, Body};

/// Check the `status` of a Response and raise an error (RequestError) if the
/// request was not a success.
///
/// Adapted from the Python `requests` library, specifically the
/// `requests.models.raise_for_status` function - link is below.
///
/// This function checks if the status code of the response is between
/// 400 and 600 to see if there was a client error or a server error. If
/// the status code, is between 200 and 400, this will return `Ok()`. This
/// is **not** a check to see if the response code is ``200 OK``.
///
/// # Credits
///
/// https://github.com/psf/requests/blob/95f456733656ed93645ff0250bfa54f6d256f6fe/requests/models.py#L945
///
pub async fn raise_for_status(request_url: &str, resp: &mut Response<Body>) -> Result<()> {
    let status_code = resp.status().as_u16();
    let reason: String;

    if (400..500).contains(&status_code) {
        // Client Error

        reason = format!(
            "{status} Client Error: {reason} for url: {url}",
            status = status_code,
            reason = resp.status().canonical_reason().unwrap_or("Unknown"),
            url = host_with_path(request_url)?,
        );
    } else if (500..600).contains(&status_code) {
        // Server Error

        reason = format!(
            "{status} Server Error: {reason} for url: {url}",
            status = status_code,
            reason = resp.status().canonical_reason().unwrap_or("Unknown"),
            url = host_with_path(request_url)?,
        );
    } else {
        // Not an error at least, so we're safe.
        return Ok(());
    }

    let resp_data = resp_to_string(resp).await?;

    let mut e = RequestError::new(status_code, reason);

    // Attempt to de-serialize the response data into a `WistiaError`
    // object, and set the `error` field. If there are any errors in
    // de-serializing the data, we populate the `message` field instead.
    if let Ok(error_data) = serde_json::from_str::<WistiaError>(&resp_data) {
        e.error = error_data;
    } else {
        e.error = WistiaError::default();
        e.error.error = resp_data.trim().to_owned();
    }

    error!("{:#?}", e);

    Err(Box::new(e))
}