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

244
lootalot_db/src/lib.rs
View File

@@ -33,8 +33,7 @@ pub type QueryResult<T> = Result<T, diesel::result::Error>;
pub type ActionResult<R> = Result<R, diesel::result::Error>;
#[derive(Serialize, Deserialize, Debug)]
enum Update {
NoUpdate,
pub enum Update {
Wealth(Wealth),
ItemAdded(Item),
ItemRemoved(Item),
@@ -43,7 +42,7 @@ enum Update {
}
#[derive(Serialize, Deserialize, Debug)]
enum Value {
pub enum Value {
Item(Item),
Claim(Claim),
ItemList(Vec<Item>),
@@ -53,10 +52,10 @@ enum Value {
#[derive(Serialize, Deserialize, Debug, Default)]
pub struct ApiResponse {
pub value: Option<Value>, // The value requested, if any
pub notify: Option<String>, // A text to notify user, if relevant
pub value: Option<Value>, // The value requested, if any
pub notify: Option<String>, // A text to notify user, if relevant
pub updates: Option<Vec<Update>>, // A list of updates, if any
pub errors: Option<String>, // A text describing errors, if any
pub errors: Option<String>, // A text describing errors, if any
}
impl ApiResponse {
@@ -68,6 +67,14 @@ impl ApiResponse {
}
}
fn push_error<S: Into<String>>(&mut self, error: S) {
if let Some(errors) = self.errors.as_mut() {
*errors = format!("{}\n{}", errors, error.into());
} else {
self.errors = Some(error.into())
}
}
fn set_value(&mut self, value: Value) {
self.value = Some(value);
}
@@ -77,24 +84,23 @@ impl ApiResponse {
}
}
pub enum ApiError {
DieselError(diesel::result::Error),
InvalidAction(String),
}
pub enum ApiActions<'a> {
pub enum ApiActions {
FetchPlayers,
FetchInventory,
// Player actions
FetchLoot(i32),
UpdateWealth(i32, f32),
BuyItems(i32, &'a Vec<(i32, Option<f32>)>),
SellItems(i32, &'a Vec<(i32, Option<f32>)>),
BuyItems(i32, Vec<(i32, Option<f32>)>),
SellItems(i32, Vec<(i32, Option<f32>)>),
ClaimItem(i32, i32),
UnclaimItem(i32, i32),
// Group actions
AddLoot(&'a Vec<Item>),
AddLoot(Vec<Item>),
}
pub enum AdminActions {
@@ -104,38 +110,26 @@ pub enum AdminActions {
//SetClaimsTimeout(pub i32),
}
pub fn execute<'a>(pool: Pool, query: ApiActions<'a>) -> Result<ApiResponse, diesel::result::Error> {
let conn = pool.get().map_err(|e| {dbg!(e); diesel::result::Error::NotFound })?;
pub fn execute(
conn: &DbConnection,
query: ApiActions,
) -> Result<ApiResponse, diesel::result::Error> {
let mut response = ApiResponse::default();
match query {
ApiActions::FetchPlayers => {
response.set_value(
Value::PlayerList(
schema::players::table.load::<models::Player>(conn)?
)
);
},
response.set_value(Value::PlayerList(models::player::Players(conn).all()?));
}
ApiActions::FetchInventory => {
response.set_value(
Value::ItemList(
models::item::Inventory(conn).all()?));
response.set_value(Value::ItemList(models::item::Inventory(conn).all()?));
}
ApiActions::FetchLoot(id) => {
response.set_value(
Value::ItemList(
models::item::LootManager(conn, id).all()?
)
);
},
response.set_value(Value::ItemList(models::item::LootManager(conn, id).all()?));
}
ApiActions::UpdateWealth(id, amount) => {
response.push_update(
Update::Wealth(
models::player::AsPlayer(conn, id)
.update_wealth(amount)?
)
);
},
response.push_update(Update::Wealth(
models::player::AsPlayer(conn, id).update_wealth(amount)?,
));
}
ApiActions::BuyItems(id, params) => {
let mut cumulated_diff: Vec<Wealth> = Vec::with_capacity(params.len());
let mut added_items: Vec<models::Item> = Vec::with_capacity(params.len());
@@ -143,7 +137,7 @@ pub fn execute<'a>(pool: Pool, query: ApiActions<'a>) -> Result<ApiResponse, die
// Use a transaction to avoid incoherant state in case of error
if let Ok((item, diff)) = conn.transaction(|| {
// Find item in inventory
let item = models::item::Inventory(conn).find(*item_id)?;
let item = models::item::Inventory(conn).find(item_id)?;
let new_item = models::item::LootManager(conn, id).add_from(&item)?;
let sell_price = match price_mod {
Some(modifier) => item.base_price as f32 * modifier,
@@ -156,134 +150,92 @@ pub fn execute<'a>(pool: Pool, query: ApiActions<'a>) -> Result<ApiResponse, die
cumulated_diff.push(diff);
response.push_update(Update::ItemAdded(item));
} else {
response.errors = Some(format!("Error adding {}", item_id));
response.push_error(format!("Error adding {}", item_id));
}
}
let all_diff = cumulated_diff.into_iter().fold(Wealth::from_gp(0.0), |sum, diff|
Wealth {
let all_diff = cumulated_diff
.into_iter()
.fold(Wealth::from_gp(0.0), |sum, diff| Wealth {
cp: sum.cp + diff.cp,
sp: sum.sp + diff.sp,
gp: sum.gp + diff.gp,
pp: sum.pp + diff.pp,
}
);
});
response.push_update(Update::Wealth(all_diff));
},
}
ApiActions::SellItems(id, params) => {
sell(conn, id, params, &mut response);
},
let mut all_results: Vec<Wealth> = Vec::with_capacity(params.len());
for (loot_id, price_mod) in params.into_iter() {
let res = conn.transaction(|| {
let deleted = models::item::LootManager(conn, id).remove(loot_id)?;
let mut sell_value = deleted.base_price as f32 / 2.0;
if let Some(modifier) = price_mod {
sell_value *= modifier;
}
models::player::AsPlayer(conn, id)
.update_wealth(sell_value)
.map(|diff| (deleted, diff))
});
if let Ok((deleted, diff)) = res {
all_results.push(diff);
response.push_update(Update::ItemRemoved(deleted));
} else {
response.push_error(format!("Error selling {}", loot_id));
}
}
let wealth = all_results
.into_iter()
.fold(Wealth::from_gp(0.0), |sum, diff| Wealth {
cp: sum.cp + diff.cp,
sp: sum.sp + diff.sp,
gp: sum.gp + diff.gp,
pp: sum.pp + diff.pp,
});
response.push_update(Update::Wealth(wealth));
}
ApiActions::ClaimItem(id, item) => {
response.push_update(
Update::ClaimAdded(
models::claim::Claims(conn)
.add(id, item)?
)
);
},
response.push_update(Update::ClaimAdded(
models::claim::Claims(conn).add(id, item)?,
));
}
ApiActions::UnclaimItem(id, item) => {
response.push_update(
Update::ClaimRemoved(
models::claim::Claims(conn)
.remove(id, item)?
)
);
},
response.push_update(Update::ClaimRemoved(
models::claim::Claims(conn).remove(id, item)?,
));
}
// Group actions
ApiActions::AddLoot(items) => {},
ApiActions::AddLoot(items) => {}
}
Ok(response)
}
/// Fetch all existing claims
pub fn fetch_claims(conn: &DbConnection) -> QueryResult<Vec<models::Claim>> {
schema::claims::table.load::<models::Claim>(conn)
}
/// Fetch all existing claims
pub fn fetch_claims(conn: &DbConnection) -> QueryResult<Vec<models::Claim>> {
schema::claims::table.load::<models::Claim>(conn)
}
/// Sell a set of items from this player chest
///
/// # Returns
/// Result containing the difference in coins after operation
pub fn sell(
conn: &DbConnection,
id: i32,
params: &Vec<(i32, Option<f32>)>,
response: &mut ApiResponse,
) {
let mut all_results: Vec<Wealth> = Vec::with_capacity(params.len());
for (loot_id, price_mod) in params.into_iter() {
let res = conn.transaction(|| {
let deleted = models::item::LootManager(conn, id).remove(*loot_id)?;
let mut sell_value = deleted.base_price as f32 / 2.0;
if let Some(modifier) = price_mod {
sell_value *= modifier;
}
models::player::AsPlayer(conn, id)
.update_wealth(sell_value)
.map(|diff| (deleted, diff))
});
if let Ok((deleted, diff)) = res {
all_results.push(diff);
response.push_update(
Update::ItemRemoved(deleted)
);
} else {
response.errors = Some(format!("Error selling {}", loot_id));
/// Resolve all pending claims and dispatch claimed items.
///
/// When a player gets an item, it's debt is increased by this item sell value
pub fn resolve_claims(conn: &DbConnection) -> QueryResult<()> {
let data = models::claim::Claims(conn).grouped_by_item()?;
dbg!(&data);
for (item, claims) in data {
match claims.len() {
1 => {
let claim = claims.get(0).unwrap();
let player_id = claim.player_id;
conn.transaction(|| {
claim.resolve_claim(conn)?;
//models::item::LootManager(self.0, 0).set_owner(claim.loot_id, claim.player_id)?;
models::player::AsPlayer(conn, player_id).update_debt(item.sell_value())
})?;
}
_ => (),
}
let wealth = all_results.into_iter().fold(Wealth::from_gp(0.0), |sum, diff| {
Wealth {
cp: sum.cp + diff.cp,
sp: sum.sp + diff.sp,
gp: sum.gp + diff.gp,
pp: sum.pp + diff.pp,
}
});
response.push_update(Update::Wealth(wealth));
}
/// Wrapper for interactions of admins with the DB.
pub struct AsAdmin<'q>(&'q DbConnection);
impl<'q> AsAdmin<'q> {
/// Adds a player to the database
///
/// Takes the player name and starting wealth (in gold value).
pub fn add_player(self, name: &str, start_wealth: f32) -> ActionResult<()> {
models::player::Players(self.0).add(name, start_wealth)?;
Ok(())
}
/// Adds a list of items to the group loot
pub fn add_loot(self, items: Vec<models::item::Item>) -> ActionResult<()> {
for item_desc in items.iter() {
models::item::LootManager(self.0, 0).add_from(item_desc)?;
}
Ok(())
}
/// Resolve all pending claims and dispatch claimed items.
///
/// When a player gets an item, it's debt is increased by this item sell value
pub fn resolve_claims(self) -> ActionResult<()> {
let data = models::claim::Claims(self.0).grouped_by_item()?;
dbg!(&data);
for (item, claims) in data {
match claims.len() {
1 => {
let claim = claims.get(0).unwrap();
let player_id = claim.player_id;
self.0.transaction(|| {
claim.resolve_claim(self.0)?;
//models::item::LootManager(self.0, 0).set_owner(claim.loot_id, claim.player_id)?;
models::player::AsPlayer(self.0, player_id).update_debt(item.sell_value())
})?;
}
_ => (),
}
}
Ok(())
}
Ok(())
}
/// Sets up a connection pool and returns it.

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")?