Struct rocketjson_data::api::response_err::ApiResponseErr

pub struct ApiResponseErr<T> {
    pub json: Result<Json<T>, ApiErrors>,
    pub status: Option<Status>,
}

Is returned by enpoints to achieve a Json response success or failure Returned can be errors in [ApiErrors]. with ApiResponseErr.err(...). To forward Errors as ApiResponseErr rjtry can be used.

Example

pub async fn db_get_users() -> Result<String, diesel::result::Error> {
    ...
}

pub async fn is_admin() -> ApiResponseErr<bool> {
    let user = rjtry!(db_get_users().await);
    user == "admin"
}

#[derive(serde::Deserialize, validator::Validate, rocketjson::JsonBody)]
pub struct LoginRequest {
    #[validate(length(min = 1))]
    username: String,
    #[validate(length(min = 1))]
    password: String
}

#[derive(serde::Serialize)]
pub struct LoginResponse {
    message: String
}

#[post("/login", data="<data>")]
pub fn login(data: LoginRequest) -> rocketjson::ApiResponseErr<LoginResponse> {
    if data.username == "admin" && data.password == "admin" {
        return rocketjson::ApiResponseErr::ok(
            rocket::http::Status::Ok,
            LoginResponse{ message: "logged in" }
        );
    }

    return rocketjson::ApiResponseErr::api_err(rocket::http::Status::InternalServerError, String::from("login failed"))
}

• Input

{
    "username": "admin",
    "password": "admin"
}

• Output (200 OK)

{
    "message": "logged in"
}

• Input

{
    "username": "test",
    "password": "test"
}

• Output (500 Internal Server Error)

{
    "error": "login failed"
}

Fields

json: Result<Json<T>, ApiErrors>

This is the Json-data sent to the client

status: Option<Status>

This is the Statuscode sent to the client, it is not included in the Json

Implementations

impl<T> ApiResponseErr<T>

pub fn ok(status: Status, json_data: T) -> Self

pub fn api_err(status: Status, error: String) -> Self

pub fn err(error: ApiErrors) -> Self

pub fn get_status(&self) -> Status

Trait Implementations

impl<T: Debug> Debug for ApiResponseErr<T>

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

Formats the value using the given formatter.

impl<'r, T> Responder<'r, 'static> for ApiResponseErr<T> where
    T: Serialize, 

fn respond_to(self, req: &'r Request<'_>) -> Result<'static>

Returns Ok if a Response could be generated successfully. Otherwise, returns an Err with a failing Status.