server/src/web_server/app_error.rs

use std::sync::Arc;

use ntex::http::StatusCode;
use ntex::web;

use ntex::web::{HttpRequest, HttpResponse};

use snafu::Snafu;

use crate::insert_header;
use crate::utils::convert_to_arc;
use crate::web_server::old_device_sensor_api::qs_parser::QSParserError;
use rust_decimal::Decimal;
use serde_json::json;

use super::old_device_sensor_api::qs_parser;




/// Главный объект ошибки [std::error::Error] для всего Web API.
///
/// В целом, все Result у Web сервера должны использовать этот Error.
#[derive(Debug, Snafu, Clone)]
#[snafu(visibility(pub))]
pub enum AppError {
    #[snafu(display("Could not read file"))]
    JsonError {
        #[snafu(source(from(serde_json::Error, convert_to_arc::<serde_json::Error>)))]
        source: Arc<serde_json::Error>
    },

    #[snafu(display("Could not read file"))]
    QSError {
        source: QSParserError
    },

    #[snafu(display("Could not read file"))]
    ServerRedisError {
        source: fred::error::Error
    },

    #[snafu(display("Could not read file"))]
    UnknownMethod {
        method: String
    },

    #[snafu(display("Could not read file"))]
    RequestTooLarge,

    #[snafu(display("API key invalid: {reason}"))]
    ApiKeyInvalid { reason: &'static str },

    #[snafu(display("Could not read file"))]
    UnitValidationFailed {
        max: Option<Decimal>,
        min: Option<Decimal>,
    },

    #[snafu(display("UTF-8 Error"))]
    Utf8Error {
        source: std::str::Utf8Error
    },

    #[snafu(display("Could not read file"))]
    UnknownBody {
        json_err: Arc<Option<serde_json::Error>>,
        query_error: Arc<Option<qs_parser::QSParserError>>,
    },

    #[snafu(display("Could not read file"))]
    DeviceNotFound {
        mac: String
    },

    #[snafu(display("Could not read file"))]
    TimeIsLongBehindNow
}

impl web::error::WebResponseError for AppError {
    fn status_code(&self) -> StatusCode {
        match self {
            AppError::JsonError { .. } => StatusCode::BAD_REQUEST,
            AppError::UnknownMethod { .. } => StatusCode::BAD_REQUEST,
            AppError::UnitValidationFailed { .. } => StatusCode::BAD_REQUEST,
            AppError::RequestTooLarge => StatusCode::PAYLOAD_TOO_LARGE,
            AppError::ServerRedisError { .. } => StatusCode::INTERNAL_SERVER_ERROR,
            AppError::ApiKeyInvalid { .. } => StatusCode::BAD_REQUEST,
            AppError::Utf8Error { .. } => StatusCode::BAD_REQUEST,
            AppError::UnknownBody { .. } => StatusCode::BAD_REQUEST,
            AppError::QSError { .. } => StatusCode::BAD_REQUEST,
            AppError::DeviceNotFound { .. } => StatusCode::BAD_REQUEST,
            AppError::TimeIsLongBehindNow { .. } => StatusCode::BAD_REQUEST
        }
    }

    fn error_response(&self, _: &HttpRequest) -> HttpResponse {
        let error_message = match self {
            AppError::JsonError { .. } => "Invalid JSON",
            AppError::UnknownMethod { .. } => "Unknown command",
            AppError::UnitValidationFailed { .. } => "Unknown command",
            AppError::RequestTooLarge => "Request is too large",
            AppError::ServerRedisError { .. } => "Internal server error",
            AppError::ApiKeyInvalid { .. } => "API Key invalid",
            AppError::Utf8Error { .. } => "Invalid UTF8 sequence",
            AppError::UnknownBody { .. } => {
                "Can't figure out where and in what encoding the main data is"
            }
            AppError::QSError { .. } => "UrlEncoded body or query params are incorrect",
            AppError::DeviceNotFound { .. } => "Device not found",
            AppError::TimeIsLongBehindNow { .. } => "Time is long behind what it should be"
        };

        let status_code = self.status_code();

        let body = json!({
            "errno": status_code.as_u16(),
            "error": error_message,
        });

        let mut resp = HttpResponse::build(status_code).json(&body);
        let headers = resp.headers_mut();


        match self {
            AppError::JsonError { source } => {
                insert_header!(headers, "X-Error-Line", source.line());
                insert_header!(headers, "X-Error-Column", source.column());
                insert_header!(
                    headers,
                    "X-Error-Description",
                    source.to_string().escape_default().collect::<String>()
                );
            }
            AppError::UnknownMethod {method} => {
                insert_header!(
                    headers,
                    "X-Unknown-Cmd",
                    method.escape_default().collect::<String>()
                );
            }
            AppError::RequestTooLarge => {
                insert_header!(headers, "X-Max-Request-Size", "10 KiB = 10240 bytes");
            }
            AppError::ApiKeyInvalid { reason } => {
                insert_header!(headers, "X-Error-Description", *reason);
            }
            AppError::QSError { source } => {
                if let QSParserError::Parsing { context: desc } = source {
                    insert_header!(
                        headers,
                        "X-Error-Description",
                        desc.escape_default().to_string()
                    );
                }
            }
            _ => {}
        };

        if cfg!(debug_assertions) {
            let error_as_string = format!("{:?}", &self);

            insert_header!(headers, "X-Full-Error", error_as_string);
        }

        resp
    }
}