99 lines
3.1 KiB
Rust
99 lines
3.1 KiB
Rust
use crate::commands::add_location::AddLocation;
|
|
use crate::commands::find::FindCommand;
|
|
use crate::commands::register::Register;
|
|
use crate::context::Context;
|
|
use crate::helper::get_player_from_req;
|
|
use crate::Result;
|
|
use geoffrey_models::models::parameters::CommandRequest;
|
|
use geoffrey_models::models::player::Player;
|
|
use geoffrey_models::models::response::api_error::GeoffreyAPIError;
|
|
use geoffrey_models::models::response::APIResponse;
|
|
use geoffrey_models::models::CommandLevel;
|
|
use serde::de::DeserializeOwned;
|
|
use serde::Serialize;
|
|
use std::fmt::Debug;
|
|
use std::sync::Arc;
|
|
use warp::filters::BoxedFilter;
|
|
use warp::Filter;
|
|
|
|
pub mod add_location;
|
|
pub mod find;
|
|
pub mod register;
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
#[allow(clippy::upper_case_acronyms)]
|
|
pub enum RequestType {
|
|
POST,
|
|
GET,
|
|
}
|
|
|
|
pub trait Command {
|
|
type Req: CommandRequest;
|
|
type Resp: Serialize + DeserializeOwned + Send;
|
|
|
|
fn command_name() -> String;
|
|
fn request_type() -> RequestType;
|
|
fn command_level() -> CommandLevel;
|
|
fn run_command(ctx: Arc<Context>, req: Self::Req, user: Option<Player>) -> Result<Self::Resp>;
|
|
|
|
fn user_is_authorized(user: &Option<Player>) -> Result<()> {
|
|
if Self::command_level() == CommandLevel::ALL {
|
|
Ok(())
|
|
} else if let Some(user) = user {
|
|
if user.auth_level >= Self::command_level() {
|
|
Ok(())
|
|
} else {
|
|
Err(GeoffreyAPIError::PermissionInsufficient)
|
|
}
|
|
} else {
|
|
Err(GeoffreyAPIError::PlayerNotRegistered)
|
|
}
|
|
}
|
|
}
|
|
|
|
pub fn handle_command<T: Command>(ctx: Arc<Context>, req: T::Req) -> Result<T::Resp> {
|
|
log::info!("Running command {}", T::command_name());
|
|
log::debug!("Request: {:?}", req);
|
|
|
|
let user = get_player_from_req(&ctx.db, &req)?;
|
|
|
|
match T::user_is_authorized(&user) {
|
|
Ok(_) => T::run_command(ctx, req, user),
|
|
Err(e) => Err(e),
|
|
}
|
|
}
|
|
|
|
#[allow(clippy::needless_return)]
|
|
pub fn create_command_filter<T: Command>(ctx: Arc<Context>) -> BoxedFilter<(impl warp::Reply,)> {
|
|
let filter = warp::path(T::command_name())
|
|
.and(warp::any().map(move || ctx.clone()))
|
|
.and(warp::body::json())
|
|
.map(|ctx: Arc<Context>, req: T::Req| {
|
|
let reply = handle_command::<T>(ctx, req);
|
|
if let Ok(reply) = reply {
|
|
log::debug!("Successfully processed command");
|
|
warp::reply::json(&APIResponse::Response::<T::Resp>(reply))
|
|
} else {
|
|
let e = reply.err().unwrap();
|
|
log::warn!("Got error when processing command: {:?}", e);
|
|
warp::reply::json(&APIResponse::<T::Resp>::Error(e))
|
|
}
|
|
});
|
|
|
|
if T::request_type() == RequestType::POST {
|
|
return filter.and(warp::post()).boxed();
|
|
} else {
|
|
return filter.and(warp::get()).boxed();
|
|
}
|
|
}
|
|
|
|
pub fn command_filter(
|
|
ctx: Arc<Context>,
|
|
) -> impl Filter<Extract = impl warp::Reply, Error = warp::Rejection> + Clone {
|
|
warp::path("command").and(
|
|
create_command_filter::<FindCommand>(ctx.clone())
|
|
.or(create_command_filter::<AddLocation>(ctx.clone()))
|
|
.or(create_command_filter::<Register>(ctx)),
|
|
)
|
|
}
|