126 lines
4.6 KiB
Rust
126 lines
4.6 KiB
Rust
use actix_cors::Cors;
|
|
use actix_files as fs;
|
|
use actix_web::{web, App, Error, HttpResponse, HttpServer};
|
|
use futures::Future;
|
|
use lootalot_db::{DbApi, Pool, QueryResult};
|
|
use std::env;
|
|
|
|
type AppPool = web::Data<Pool>;
|
|
|
|
/// Wraps call to the DbApi and process its result as a async HttpResponse
|
|
///
|
|
/// Provides a convenient way to call the api inside a route definition. Given a connection pool,
|
|
/// access to the api is granted in a closure. The closure is called in a blocking way and should
|
|
/// return a QueryResult.
|
|
/// If the query succeeds, it's result is returned as JSON data. Otherwise, an InternalServerError
|
|
/// is returned.
|
|
///
|
|
/// # Usage
|
|
/// ```
|
|
/// (...)
|
|
/// .route("path/to/",
|
|
/// move |pool: web::Data<Pool>| {
|
|
/// // user data can be processed here
|
|
/// // ...
|
|
/// db_call(pool, move |api| {
|
|
/// // ...do what you want with the api
|
|
/// }
|
|
/// }
|
|
/// )
|
|
/// ```
|
|
pub fn db_call<
|
|
J: serde::ser::Serialize + Send + 'static,
|
|
Q: Fn(DbApi) -> QueryResult<J> + Send + 'static,
|
|
>(
|
|
pool: AppPool,
|
|
query: Q,
|
|
) -> impl Future<Item = HttpResponse, Error = Error> {
|
|
let conn = pool.get().unwrap();
|
|
web::block(move || {
|
|
let api = DbApi::with_conn(&conn);
|
|
query(api)
|
|
})
|
|
.then(|res| match res {
|
|
Ok(players) => HttpResponse::Ok().json(players),
|
|
Err(e) => {
|
|
dbg!(&e);
|
|
HttpResponse::InternalServerError().finish()
|
|
}
|
|
})
|
|
}
|
|
|
|
pub(crate) fn serve() -> std::io::Result<()> {
|
|
let www_root: String = env::var("WWW_ROOT").expect("WWW_ROOT must be set");
|
|
dbg!(&www_root);
|
|
let pool = lootalot_db::create_pool();
|
|
|
|
HttpServer::new(move || {
|
|
App::new()
|
|
.data(pool.clone())
|
|
.wrap(
|
|
Cors::new()
|
|
.allowed_origin("http://localhost:8080")
|
|
.allowed_methods(vec!["GET", "POST"])
|
|
.max_age(3600),
|
|
)
|
|
.service(
|
|
web::scope("/api")
|
|
.route(
|
|
"/players",
|
|
web::get().to_async(move |pool: AppPool| {
|
|
db_call(pool, move |api| api.fetch_players())
|
|
}),
|
|
)
|
|
.route(
|
|
"/claims",
|
|
web::get().to_async(move |pool: AppPool| {
|
|
db_call(pool, move |api| api.fetch_claims())
|
|
}),
|
|
)
|
|
.route(
|
|
"/{player_id}/update-wealth/{amount}",
|
|
web::get().to_async(move |pool: AppPool, data: web::Path<(i32, f32)>| {
|
|
db_call(pool, move |api| api.as_player(data.0).update_wealth(data.1))
|
|
}),
|
|
)
|
|
.route(
|
|
"/{player_id}/loot",
|
|
web::get().to_async(move |pool: AppPool, player_id: web::Path<i32>| {
|
|
db_call(pool, move |api| api.as_player(*player_id).loot())
|
|
}),
|
|
)
|
|
.route(
|
|
"/{player_id}/claim/{item_id}",
|
|
web::get().to_async(move |pool: AppPool, data: web::Path<(i32, i32)>| {
|
|
db_call(pool, move |api| api.as_player(data.0).claim(data.1))
|
|
}),
|
|
)
|
|
.route(
|
|
"/{player_id}/unclaim/{item_id}",
|
|
web::get().to_async(move |pool: AppPool, data: web::Path<(i32, i32)>| {
|
|
db_call(pool, move |api| api.as_player(data.0).unclaim(data.1))
|
|
}),
|
|
)
|
|
.route(
|
|
"/admin/resolve-claims",
|
|
web::get().to_async(move |pool: AppPool| {
|
|
db_call(pool, move |api| api.as_admin().resolve_claims())
|
|
}),
|
|
)
|
|
.route(
|
|
"/admin/add-player/{name}/{wealth}",
|
|
web::get().to_async(
|
|
move |pool: AppPool, data: web::Path<(String, f32)>| {
|
|
db_call(pool, move |api| {
|
|
api.as_admin().add_player(&data.0, data.1)
|
|
})
|
|
},
|
|
),
|
|
),
|
|
)
|
|
.service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
|
|
})
|
|
.bind("127.0.0.1:8088")?
|
|
.run()
|
|
}
|