rust/lootalot
1
0
Fork 0
Code Issues 3 Pull Requests Releases Wiki Activity

fixes errors, cleans up

Browse Source
This commit is contained in:
Arthur Gerbaud
2019-10-17 11:58:00 +02:00
parent 2222422f8a
commit 3cc45397da
2 changed files with 182 additions and 364 deletions
Download Patch File Download Diff File Expand all files Collapse all files

302
src/server.rs
View File

@@ -1,44 +1,24 @@
use actix_cors::Cors;
use actix_files as fs;
use actix_web::{web, App, Error, HttpResponse, HttpServer};
use actix_web::{web, middleware, App, Error, HttpResponse, HttpServer};
use futures::Future;
use lootalot_db::{DbApi, Pool, QueryResult};
use lootalot_db::{Item, LootManager};
use lootalot_db as db;
use serde::{Deserialize, Serialize};
use std::env;
use std::default;
type AppPool = web::Data<Pool>;
use lootalot_db as db;
/// 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, Q>(pool: AppPool, query: Q) -> impl Future<Item = HttpResponse, Error = Error>
where
J: serde::ser::Serialize + Send + 'static,
Q: Fn(DbConnection) -> ApiResponse<J> + Send + 'static,
type AppPool = web::Data<db::Pool>;
type PlayerId = web::Path<i32>;
type ItemId = web::Json<i32>;
type ItemListWithMods = web::Json<Vec<(i32, Option<f32>)>>;
/// Wraps call to the database query and convert its result as a async HttpResponse
pub fn db_call(
pool: AppPool,
query: db::ApiActions,
) -> impl Future<Item = HttpResponse, Error = Error>
{
let conn = pool.get().unwrap();
web::block(move || query(conn)).then(|res| match res {
web::block(move || db::execute(&conn, query)).then(|res| match res {
Ok(r) => HttpResponse::Ok().json(r),
Err(e) => {
dbg!(&e);
@@ -47,205 +27,91 @@ where
})
}
mod endpoints {
use super::*;
#[derive(Serialize, Deserialize, Debug)]
pub struct PlayerClaim {
player_id: i32,
item_id: i32,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct WealthUpdate {
player_id: i32,
value_in_gp: f32,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct NewPlayer {
pub name: String,
pub wealth: f32,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct LootUpdate {
player_id: i32,
items: Vec<(i32, Option<f32>)>,
}
pub fn players_list(pool: AppPool) -> impl Future<Item = HttpResponse, Error = Error> {
db_call(pool, move |conn| {
let (value, errors) = match db::Players(conn).all() {
Ok(v) => (Some(v), None),
Err(e) => (None, Some(e.to_string())),
};
ApiResponse {
value,
errors,
..Default::default()
}
})
}
pub fn player_loot(
pool: AppPool,
player_id: web::Path<i32>,
) -> impl Future<Item = HttpResponse, Error = Error> {
db_call(pool, move |conn| {
let (value, errors) = {
match db::LootManager(&conn, *player_id).all() {
Ok(v) => (Some(v), None),
Err(e) => (None, Some(e.to_string())),
}
};
ApiResponse {
value,
errors,
..Default::default()
}
})
}
pub fn update_wealth(
pool: AppPool,
(player, data): (web::Path<i32>, web::Json<WealthUpdate>),
) -> impl Future<Item = HttpResponse, Error = Error> {
db_call(pool, move |conn| {
let (updates, errors) =
match db::AsPlayer(conn, player)
.update_wealth(data.value_in_gp) {
Ok(w) => (Some(vec![w.as_tuple(),]), None),
Err(e) => (None, Some(e.to_string())),
};
ApiResponse {
updates,
errors,
..Default::default()
}
})
}
pub fn buy_item(
pool: AppPool,
data: web::Json<LootUpdate>,
) -> impl Future<Item = HttpResponse, Error = Error> {
db_call(pool, move |api| {
api.as_player(data.player_id).buy(&data.items)
})
}
pub fn sell_item(
pool: AppPool,
data: web::Json<LootUpdate>,
) -> impl Future<Item = HttpResponse, Error = Error> {
db_call(pool, move |api| {
api.as_player(data.player_id).sell(&data.items)
})
}
pub fn player_claims(pool: AppPool) -> impl Future<Item = HttpResponse, Error = Error> {
db_call(pool, move |api| api.fetch_claims())
}
pub fn put_claim(
pool: AppPool,
(player, loot): (web::Path<i32>, web::Json<PlayerClaim>),
) -> impl Future<Item = HttpResponse, Error = Error> {
db_call(pool, move |api| api.as_player(*player).claim(loot.item_id))
}
pub fn delete_claim(
pool: AppPool,
(player, data): (web::Path<i32>, web::Json<PlayerClaim>),
) -> impl Future<Item = HttpResponse, Error = Error> {
db_call(pool, move |api| {
api.as_player(*player).unclaim(data.item_id)
})
}
fn configure_app(config: &mut web::ServiceConfig) {
config.service(
web::scope("/api")
.service(
web::scope("/players")
.service(
web::resource("/").route(
web::get().to_async(|pool| db_call(pool, db::ApiActions::FetchPlayers)),
), //.route(web::post().to_async(endpoints::new_player))
) // List of players
.service(
web::scope("/{player_id}")
//.route(web::get().to_async(...)) // Details of player
.service(
web::resource("/claims")
//.route(web::get().to_async(endpoints::player_claims))
.route(web::put().to_async(
|pool, (player, data): (PlayerId, ItemId)| {
db_call(pool, db::ApiActions::ClaimItem(*player, *data))
},
))
.route(web::delete().to_async(
|pool, (player, data): (PlayerId, ItemId)| {
db_call(
pool,
db::ApiActions::UnclaimItem(*player, *data),
)
},
)),
)
.service(
web::resource("/wealth")
//.route(web::get().to_async(...))
.route(web::put().to_async(
|pool, (player, data): (PlayerId, web::Json<f32>)| {
db_call(
pool,
db::ApiActions::UpdateWealth(*player, *data),
)
},
)),
)
.service(
web::resource("/loot")
.route(web::get().to_async(|pool, player: PlayerId| {
db_call(pool, db::ApiActions::FetchLoot(*player))
}))
.route(web::put().to_async(
move |pool, (player, data): (PlayerId, ItemListWithMods)| {
db_call(pool, db::ApiActions::BuyItems(*player, data.into_inner()))
},
))
.route(web::delete().to_async(
move |pool, (player, data): (PlayerId, ItemListWithMods)| {
db_call(pool, db::ApiActions::SellItems(*player, data.into_inner()))
},
)),
),
),
)
//.route("/claims", web::get().to_async(endpoints::player_claims))
.route(
"/items",
web::get()
.to_async(move |pool: AppPool| db_call(pool, db::ApiActions::FetchInventory)),
),
);
}
pub(crate) fn serve() -> std::io::Result<()> {
pub fn serve() -> std::io::Result<()> {
let www_root: String = env::var("WWW_ROOT").expect("WWW_ROOT must be set");
let pool = db::create_pool();
dbg!(&www_root);
let pool = lootalot_db::create_pool();
HttpServer::new(move || {
App::new()
.data(pool.clone())
.configure(configure_app)
.wrap(
Cors::new()
.allowed_origin("http://localhost:8080")
.allowed_methods(vec!["GET", "POST", "PUT", "DELETE", "OPTIONS"])
.max_age(3600),
)
.service(
web::scope("/api")
.service(
web::scope("/players")
.service(
web::resource("/")
.route(web::get().to_async(endpoints::players_list)),
) // List of players
//.route(web::put().to_async(endpoints::new_player)) // Create/Update player
.service(
web::scope("/{player_id}")
//.route(web::get().to_async(...)) // Details of player
.service(
web::resource("/claims")
//.route(web::get().to_async(endpoints::player_claims))
.route(web::put().to_async(endpoints::put_claim))
.route(web::delete().to_async(endpoints::delete_claim)),
)
.service(
web::resource("/wealth")
//.route(web::get().to_async(...))
.route(web::put().to_async(endpoints::update_wealth)),
)
.service(
web::resource("/loot")
.route(web::get().to_async(endpoints::player_loot))
.route(web::put().to_async(endpoints::buy_item))
.route(web::delete().to_async(endpoints::sell_item)),
),
),
)
.route("/claims", web::get().to_async(endpoints::player_claims))
.route(
"/items",
web::get().to_async(move |pool: AppPool| {
db_call(pool, move |api| api.fetch_inventory())
}),
)
.service(
web::scope("/admin")
.route(
"/resolve-claims",
web::get().to_async(move |pool: AppPool| {
db_call(pool, move |api| api.as_admin().resolve_claims())
}),
)
.route(
"/add-loot",
web::post().to_async(
move |pool: AppPool, data: web::Json<Vec<Item>>| {
db_call(pool, move |api| {
api.as_admin().add_loot(data.to_vec())
})
},
),
)
.route(
"/add-player",
web::get().to_async(
move |pool: AppPool, data: web::Json<endpoints::NewPlayer>| {
db_call(pool, move |api| {
api.as_admin().add_player(&data.name, data.wealth)
})
},
),
),
),
)
.wrap(middleware::Logger::default())
.service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
})
.bind("127.0.0.1:8088")?