84 lines
3.7 KiB
Rust
84 lines
3.7 KiB
Rust
use std::fmt;
|
|
use serde_json::json;
|
|
use actix_http::ResponseBuilder;
|
|
use actix_web::http::StatusCode;
|
|
use actix_web::*;
|
|
|
|
#[derive(Debug)]
|
|
pub enum ResponseError {
|
|
Internal(String),
|
|
BadRequest(String),
|
|
InvalidToken(String),
|
|
NotFound(String),
|
|
IndexNotFound(String),
|
|
DocumentNotFound(String),
|
|
UpdateNotFound(u64),
|
|
MissingHeader(String),
|
|
FilterParsing(String),
|
|
BadParameter(String, String),
|
|
OpenIndex(String),
|
|
CreateIndex(String),
|
|
CreateTransaction,
|
|
CommitTransaction,
|
|
Schema,
|
|
InferPrimaryKey,
|
|
InvalidIndexUid,
|
|
Maintenance,
|
|
}
|
|
|
|
impl fmt::Display for ResponseError {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
match self {
|
|
Self::Internal(err) => write!(f, "Internal server error: {}", err),
|
|
Self::BadRequest(err) => write!(f, "Bad request: {}", err),
|
|
Self::InvalidToken(err) => write!(f, "Invalid API key: {}", err),
|
|
Self::NotFound(err) => write!(f, "{} not found", err),
|
|
Self::IndexNotFound(index_uid) => write!(f, "Index {} not found", index_uid),
|
|
Self::DocumentNotFound(document_id) => write!(f, "Document with id {} not found", document_id),
|
|
Self::UpdateNotFound(update_id) => write!(f, "Update with id {} not found", update_id),
|
|
Self::MissingHeader(header) => write!(f, "Header {} is missing", header),
|
|
Self::BadParameter(param, err) => write!(f, "Url parameter {} error: {}", param, err),
|
|
Self::OpenIndex(err) => write!(f, "Impossible to open index; {}", err),
|
|
Self::CreateIndex(err) => write!(f, "Impossible to create index; {}", err),
|
|
Self::CreateTransaction => write!(f, "Impossible to create transaction"),
|
|
Self::CommitTransaction => write!(f, "Impossible to commit transaction"),
|
|
Self::Schema => write!(f, "Internal schema is innaccessible"),
|
|
Self::InferPrimaryKey => write!(f, "Could not infer primary key"),
|
|
Self::InvalidIndexUid => write!(f, "Index must have a valid uid; Index uid can be of type integer or string only composed of alphanumeric characters, hyphens (-) and underscores (_)."),
|
|
Self::Maintenance => write!(f, "Server is in maintenance, please try again later"),
|
|
Self::FilterParsing(err) => write!(f, "parsing error: {}", err),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl error::ResponseError for ResponseError {
|
|
fn error_response(&self) -> HttpResponse {
|
|
ResponseBuilder::new(self.status_code()).json(json!({
|
|
"message": self.to_string(),
|
|
}))
|
|
}
|
|
|
|
fn status_code(&self) -> StatusCode {
|
|
match *self {
|
|
Self::Internal(_) => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::BadRequest(_) => StatusCode::BAD_REQUEST,
|
|
Self::InvalidToken(_) => StatusCode::FORBIDDEN,
|
|
Self::NotFound(_) => StatusCode::NOT_FOUND,
|
|
Self::IndexNotFound(_) => StatusCode::NOT_FOUND,
|
|
Self::DocumentNotFound(_) => StatusCode::NOT_FOUND,
|
|
Self::UpdateNotFound(_) => StatusCode::NOT_FOUND,
|
|
Self::MissingHeader(_) => StatusCode::UNAUTHORIZED,
|
|
Self::BadParameter(_, _) => StatusCode::BAD_REQUEST,
|
|
Self::OpenIndex(_) => StatusCode::BAD_REQUEST,
|
|
Self::CreateIndex(_) => StatusCode::BAD_REQUEST,
|
|
Self::CreateTransaction => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::CommitTransaction => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::Schema => StatusCode::INTERNAL_SERVER_ERROR,
|
|
Self::InferPrimaryKey => StatusCode::BAD_REQUEST,
|
|
Self::InvalidIndexUid => StatusCode::BAD_REQUEST,
|
|
Self::Maintenance => StatusCode::SERVICE_UNAVAILABLE,
|
|
Self::FilterParsing(_) => StatusCode::BAD_REQUEST,
|
|
}
|
|
}
|
|
}
|