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

moves API logic inside its own module

Browse Source
This commit is contained in:
Arthur Gerbaud
2019-10-17 12:56:07 +02:00
parent 3cc45397da
commit 185e1403e3
6 changed files with 252 additions and 196 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
src/api.rs Normal file
View File

@@ -0,0 +1,166 @@
use lootalot_db::{self as db, DbConnection, QueryResult};
/// Every possible update which can happen during a query
#[derive(Serialize, Deserialize, Debug)]
pub enum Update {
Wealth(db::Wealth),
ItemAdded(db::Item),
ItemRemoved(db::Item),
ClaimAdded(db::Claim),
ClaimRemoved(db::Claim),
}
/// Every value which can be queried
#[derive(Serialize, Deserialize, Debug)]
pub enum Value {
Item(db::Item),
Claim(db::Claim),
ItemList(Vec<db::Item>),
ClaimList(Vec<db::Claim>),
PlayerList(Vec<db::Player>),
}
/// A generic response for all queries
#[derive(Serialize, Deserialize, Debug, Default)]
pub struct ApiResponse {
/// The value requested, if any
pub value: Option<Value>,
/// A text to notify user, if relevant
pub notification: Option<String>,
/// A list of updates, if any
pub updates: Option<Vec<Update>>,
/// A text describing errors, if any
pub errors: Option<String>,
}
impl ApiResponse {
fn push_update(&mut self, update: Update) {
if let Some(v) = self.updates.as_mut() {
v.push(update);
} else {
self.updates = Some(vec![update]);
}
}
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);
}
fn notify<S: Into<String>>(&mut self, text: S) {
self.notification = Some(text.into());
}
}
pub enum ApiError {
DieselError(diesel::result::Error),
InvalidAction(String),
}
/// Every allowed queries on the database
pub enum ApiActions {
FetchPlayers,
FetchInventory,
FetchClaims,
// Player actions
FetchLoot(i32),
UpdateWealth(i32, f32),
BuyItems(i32, Vec<(i32, Option<f32>)>),
SellItems(i32, Vec<(i32, Option<f32>)>),
ClaimItem(i32, i32),
UnclaimItem(i32, i32),
// Group actions
AddLoot(Vec<db::Item>),
}
pub enum AdminActions {
AddPlayer(String, f32),
//AddInventoryItem(pub String, pub i32),
ResolveClaims,
//SetClaimsTimeout(pub i32),
}
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(db::Players(conn).all()?));
}
ApiActions::FetchInventory => {
response.set_value(Value::ItemList(db::Inventory(conn).all()?));
}
ApiActions::FetchClaims => {
response.set_value(Value::ClaimList(db::fetch_claims(conn)?));
}
ApiActions::FetchLoot(id) => {
response.set_value(Value::ItemList(db::LootManager(conn, id).all()?));
}
ApiActions::UpdateWealth(id, amount) => {
response.push_update(Update::Wealth(
db::AsPlayer(conn, id).update_wealth(amount)?,
));
}
ApiActions::BuyItems(id, params) => {
let mut cumulated_diff: Vec<db::Wealth> = Vec::with_capacity(params.len());
let mut added_items: u16 = 0;
for (item_id, price_mod) in params.into_iter() {
// Use a transaction to avoid incoherant state in case of error
if let Ok((item, diff)) = db::buy_item_from_inventory(conn, id, item_id, price_mod) {
cumulated_diff.push(diff);
response.push_update(Update::ItemAdded(item));
added_items += 1;
} else {
response.push_error(format!("Error adding {}", item_id));
}
}
response.notify(format!("Added {} items", added_items));
response.push_update(Update::Wealth(
cumulated_diff
.into_iter()
.fold(db::Wealth::from_gp(0.0), |acc, i| acc + i),
));
}
ApiActions::SellItems(id, params) => {
let mut all_results: Vec<db::Wealth> = Vec::with_capacity(params.len());
let mut sold_items: u16 = 0;
for (loot_id, price_mod) in params.into_iter() {
if let Ok((deleted, diff)) = db::sell_item_transaction(conn, id, loot_id, price_mod) {
all_results.push(diff);
response.push_update(Update::ItemRemoved(deleted));
sold_items += 1;
} else {
response.push_error(format!("Error selling {}", loot_id));
}
}
response.notify(format!("Sold {} items", sold_items));
response.push_update(Update::Wealth(
all_results
.into_iter()
.fold(db::Wealth::from_gp(0.0), |acc, i| acc + i),
));
}
ApiActions::ClaimItem(id, item) => {
response.push_update(Update::ClaimAdded(
db::Claims(conn).add(id, item)?,
));
}
ApiActions::UnclaimItem(id, item) => {
response.push_update(Update::ClaimRemoved(
db::Claims(conn).remove(id, item)?,
));
}
// Group actions
ApiActions::AddLoot(items) => {}
}
Ok(response)
}

0
src/lib.rs Normal file
View File

3
src/main.rs
View File

@@ -2,9 +2,10 @@ extern crate actix_web;
extern crate dotenv;
extern crate env_logger;
extern crate lootalot_db;
extern crate serde;
#[macro_use] extern crate serde;
mod server;
mod api;
fn main() {
std::env::set_var("RUST_LOG", "actix_web=info");

24
src/server.rs
View File

@@ -5,6 +5,7 @@ use futures::Future;
use std::env;
use lootalot_db as db;
use crate::api;
type AppPool = web::Data<db::Pool>;
type PlayerId = web::Path<i32>;
@@ -14,11 +15,11 @@ 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,
query: api::ApiActions,
) -> impl Future<Item = HttpResponse, Error = Error>
{
let conn = pool.get().unwrap();
web::block(move || db::execute(&conn, query)).then(|res| match res {
web::block(move || api::execute(&conn, query)).then(|res| match res {
Ok(r) => HttpResponse::Ok().json(r),
Err(e) => {
dbg!(&e);
@@ -28,13 +29,14 @@ pub fn db_call(
}
fn configure_app(config: &mut web::ServiceConfig) {
use api::ApiActions as Q;
config.service(
web::scope("/api")
.service(
web::scope("/players")
.service(
web::resource("/").route(
web::get().to_async(|pool| db_call(pool, db::ApiActions::FetchPlayers)),
web::get().to_async(|pool| db_call(pool, Q::FetchPlayers)),
), //.route(web::post().to_async(endpoints::new_player))
) // List of players
.service(
@@ -45,14 +47,14 @@ fn configure_app(config: &mut web::ServiceConfig) {
//.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))
db_call(pool, Q::ClaimItem(*player, *data))
},
))
.route(web::delete().to_async(
|pool, (player, data): (PlayerId, ItemId)| {
db_call(
pool,
db::ApiActions::UnclaimItem(*player, *data),
Q::UnclaimItem(*player, *data),
)
},
)),
@@ -64,7 +66,7 @@ fn configure_app(config: &mut web::ServiceConfig) {
|pool, (player, data): (PlayerId, web::Json<f32>)| {
db_call(
pool,
db::ApiActions::UpdateWealth(*player, *data),
Q::UpdateWealth(*player, *data),
)
},
)),
@@ -72,26 +74,26 @@ fn configure_app(config: &mut web::ServiceConfig) {
.service(
web::resource("/loot")
.route(web::get().to_async(|pool, player: PlayerId| {
db_call(pool, db::ApiActions::FetchLoot(*player))
db_call(pool, Q::FetchLoot(*player))
}))
.route(web::put().to_async(
move |pool, (player, data): (PlayerId, ItemListWithMods)| {
db_call(pool, db::ApiActions::BuyItems(*player, data.into_inner()))
db_call(pool, Q::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()))
db_call(pool, Q::SellItems(*player, data.into_inner()))
},
)),
),
),
)
//.route("/claims", web::get().to_async(endpoints::player_claims))
.route("/claims", web::get().to_async(|pool| db_call(pool, Q::FetchClaims)))
.route(
"/items",
web::get()
.to_async(move |pool: AppPool| db_call(pool, db::ApiActions::FetchInventory)),
.to_async(move |pool: AppPool| db_call(pool, Q::FetchInventory)),
),
);
}