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

Compare commits

base: rust:342a66475d3802f06f8b4b21009197316bfd7dbf
Branches Tags
rust:master rust:keep_track_of_all_loot rust:refactor_user_action_as_trait
...
compare: rust:keep_track_of_all_loot
Branches Tags
rust:keep_track_of_all_loot rust:master rust:refactor_user_action_as_trait

6 Commits
342a66475d ... keep_track

Author SHA1 Message Date
Artus
d152a999c9 fixes errors 2020-01-09 15:12:51 +01:00
Artus
f9cd09431d merge shop and looted tables 2020-01-09 13:25:36 +01:00
Artus
6149dfd297 will need to clean up db API 2020-01-05 15:37:40 +01:00
Artus
a47646bd5f adds AddPlayer endpoint 2019-12-18 15:22:20 +01:00
Artus
2c87713818 deletes old frontend 2019-12-15 16:03:25 +01:00
Artus
b19d56fd9a updates for prod env 2019-12-15 16:02:00 +01:00
37 changed files with 379 additions and 8870 deletions
Expand all files Collapse all files

3
lootalot_db/migrations/2019-06-10-123922_create_items/down.sql
View File

@@ -1,3 +1,2 @@
DROP TABLE items;
DROP TABLE looted;
DROP TABLE shop;
DROP TABLE loot;

10
lootalot_db/migrations/2019-06-10-123922_create_items/up.sql
View File

@@ -5,8 +5,8 @@ CREATE TABLE items (
base_price INTEGER NOT NULL
);
-- The items that have been looted
CREATE TABLE looted (
-- The loot
CREATE TABLE loot (
id INTEGER PRIMARY KEY NOT NULL,
name VARCHAR NOT NULL,
base_price INTEGER NOT NULL,
@@ -14,9 +14,3 @@ CREATE TABLE looted (
FOREIGN KEY (owner_id) REFERENCES players(id)
);
-- The items that are available in shop
CREATE TABLE shop (
id INTEGER PRIMARY KEY NOT NULL,
name VARCHAR NOT NULL,
base_price INTEGER NOT NULL
);

338
lootalot_db/src/lib.rs
View File

@@ -29,7 +29,7 @@ pub type DbConnection = SqliteConnection;
pub type Pool = r2d2::Pool<ConnectionManager<DbConnection>>;
/// The result of a query on DB
pub type QueryResult<T> = Result<T, diesel::result::Error>;
pub type UpdateResult = QueryResult<Update>;
pub type UpdateResult = QueryResult<Vec<Update>>;
/// Sets up a connection pool and returns it.
/// Uses the DATABASE_URL environment variable (must be set)
@@ -43,36 +43,36 @@ pub fn create_pool() -> Pool {
}
/// Every possible update which can happen during a query
/// Updates are relative to a Player
#[derive(Serialize, Deserialize, Debug)]
pub enum Update {
Wealth(Wealth),
ItemAdded(Item),
ItemRemoved(Item),
ItemBought(Item),
ItemSold(Item),
ClaimAdded(Claim),
ClaimRemoved(Claim),
}
impl Update {
/// Change back what has been updated
fn undo(&self, conn: &DbConnection, id: i32) -> UpdateResult {
Ok(match self {
Update::Wealth(diff) => AsPlayer(conn, id).update_wealth(-diff.to_gp())?,
Update::ItemAdded(item) => LootManager(conn, id).find(item.id)?.remove(conn)?,
Update::ItemRemoved(item) => LootManager(conn, id).add_from(&item)?,
fn undo(&self, conn: &DbConnection, id: i32) -> QueryResult<()> {
match self {
Update::Wealth(diff) => { AsPlayer(conn, id).update_wealth(-diff.to_gp())?; },
Update::ItemAdded(item) => { diesel::delete(crate::schema::loot::table.find(item.id))
.execute(conn)?; },
Update::ItemRemoved(item) => { LootManager(conn, id).add_from(&item)?; },
Update::ItemBought(item) => { LootManager(conn, id).change_owner(item.id, models::item::OF_SHOP)?;},
Update::ItemSold(item) => { LootManager(conn, models::item::SOLD).change_owner(item.id, id)?; },
// Unused for now
Update::ClaimAdded(claim) => Update::ClaimRemoved(*claim),
Update::ClaimRemoved(claim) => Update::ClaimAdded(*claim),
})
Update::ClaimAdded(claim) => {},
Update::ClaimRemoved(claim) => {},
};
Ok(())
}
}
/// TODO: use this to wrap update in UpdateResult, allowing unified interface
/// whether a query makes multiple updates or just one.
enum OneOrMore {
One(Update),
More(Vec<Update>),
}
/// Every value which can be queried
#[derive(Debug)]
pub enum Value {
@@ -99,82 +99,6 @@ impl serde::Serialize for Value {
}
}
/// Sells a single item inside a transaction
///
/// # Returns
/// The deleted entity and the updated Wealth (as a difference from previous value)
pub fn sell_item_transaction(
conn: &DbConnection,
id: i32,
loot_id: i32,
price_mod: Option<f64>,
) -> QueryResult<(Update, Wealth)> {
conn.transaction(|| {
let to_delete = LootManager(conn, id).find(loot_id)?;
let mut sell_value = to_delete.sell_value() as f64;
if let Some(modifier) = price_mod {
sell_value *= modifier;
}
let deleted = to_delete.remove(conn)?;
if let Update::Wealth(wealth) = AsPlayer(conn, id).update_wealth(sell_value)? {
Ok((deleted, wealth))
} else {
Err(diesel::result::Error::RollbackTransaction)
}
})
}
/// Buys a single item, copied from inventory.
/// Runs inside a transaction
///
/// # Returns
/// The created entity and the updated Wealth (as a difference from previous value)
pub fn buy_item_from_inventory(
conn: &DbConnection,
id: i32,
item_id: i32,
price_mod: Option<f64>,
) -> QueryResult<(Update, Wealth)> {
conn.transaction(|| {
// Find item in inventory
let item = Inventory(conn).find(item_id)?;
let new_item = LootManager(conn, id).add_from(&item)?;
let sell_price = match price_mod {
Some(modifier) => item.value() * modifier,
None => item.value(),
};
if let Update::Wealth(diff) = AsPlayer(conn, id).update_wealth(-sell_price)? {
Ok((new_item, diff))
} else {
Err(diesel::result::Error::RollbackTransaction)
}
})
}
pub fn buy_item_from_shop(
conn: &DbConnection,
id: i32,
item_id: i32,
price_mod: Option<f64>,
) -> QueryResult<(Update, Wealth)> {
conn.transaction(|| {
let shop = Shop(conn);
// Find item in inventory
let item = shop.get(item_id)?;
let new_item = LootManager(conn, id).add_from(&item)?;
let _deleted = shop.remove(item_id)?;
let sell_price = match price_mod {
Some(modifier) => item.value() * modifier,
None => item.value(),
};
if let Update::Wealth(diff) = AsPlayer(conn, id).update_wealth(-sell_price)? {
Ok((new_item, diff))
} else {
Err(diesel::result::Error::RollbackTransaction)
}
})
}
/// Resolve all pending claims and dispatch claimed items.
///
@@ -239,234 +163,6 @@ pub fn split_and_share(
}
}
}
Ok(Update::Wealth(Wealth::from_gp(shared_total)))
Ok(vec!(Update::Wealth(Wealth::from_gp(shared_total))))
})
}
#[cfg(none)]
mod tests_old {
use super::*;
type TestConnection = DbConnection;
/// Return a connection to a fresh database (stored in memory)
fn test_connection() -> TestConnection {
let test_conn = DbConnection::establish(":memory:").unwrap();
diesel_migrations::run_pending_migrations(&test_conn).unwrap();
test_conn
}
/// When migrations are run, a special player with id 0 and name "Groupe"
/// must be created.
#[test]
fn global_group_is_autocreated() {
let conn = test_connection();
let players = DbApi::with_conn(&conn).fetch_players().unwrap();
assert_eq!(players.len(), 1);
let group = players.get(0).unwrap();
assert_eq!(group.id, 0);
assert_eq!(group.name, "Groupe".to_string());
}
/// When a player updates wealth, a difference is returned by API.
/// Added to the previous amount of coins, it should equal the updated weath.
#[test]
fn as_player_updates_wealth() {
let conn = test_connection();
DbApi::with_conn(&conn)
.as_admin()
.add_player("PlayerName", 403.21)
.unwrap();
let diff = DbApi::with_conn(&conn)
.as_player(1)
.update_wealth(-401.21)
.ok();
// Check the returned diff
assert_eq!(diff, Some((-1, -2, -1, -4)));
let diff = diff.unwrap();
let players = DbApi::with_conn(&conn).fetch_players().unwrap();
let player = players.get(1).unwrap();
// Check that we can add old value to return diff to get resulting value
assert_eq!(
(player.cp, player.sp, player.gp, player.pp),
(1 + diff.0, 2 + diff.1, 3 + diff.2, 4 + diff.3)
);
}
#[test]
fn as_admin_add_player() {
let conn = test_connection();
let result = DbApi::with_conn(&conn)
.as_admin()
.add_player("PlayerName", 403.21);
assert_eq!(result.is_ok(), true);
let players = DbApi::with_conn(&conn).fetch_players().unwrap();
assert_eq!(players.len(), 2);
let new_player = players.get(1).unwrap();
assert_eq!(new_player.name, "PlayerName");
assert_eq!(
(new_player.cp, new_player.sp, new_player.gp, new_player.pp),
(1, 2, 3, 4)
);
}
#[test]
fn as_admin_resolve_claims() {
let conn = test_connection();
let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
assert_eq!(claims.len(), 0);
// Add items
assert_eq!(
DbApi::with_conn(&conn)
.as_admin()
.add_loot(vec![("Épée", 40), ("Arc", 40),])
.is_ok(),
true
);
// Add players
DbApi::with_conn(&conn)
.as_admin()
.add_player("Player1", 0.0)
.unwrap();
DbApi::with_conn(&conn)
.as_admin()
.add_player("Player2", 0.0)
.unwrap();
// Put claims on one different item each
DbApi::with_conn(&conn).as_player(1).claim(1).unwrap();
DbApi::with_conn(&conn).as_player(2).claim(2).unwrap();
let result = DbApi::with_conn(&conn).as_admin().resolve_claims();
assert_eq!(result.is_ok(), true);
// Check that both players received an item
let players = DbApi::with_conn(&conn).fetch_players().unwrap();
for &i in [1, 2].into_iter() {
assert_eq!(
DbApi::with_conn(&conn).as_player(i).loot().unwrap().len(),
1
);
let player = players.get(i as usize).unwrap();
assert_eq!(player.debt, 20);
}
}
#[test]
fn as_player_claim_item() {
let conn = test_connection();
DbApi::with_conn(&conn)
.as_admin()
.add_player("Player", 0.0)
.unwrap();
DbApi::with_conn(&conn)
.as_admin()
.add_loot(vec![("Épée", 25)])
.unwrap();
// Claim an existing item
let result = DbApi::with_conn(&conn).as_player(1).claim(1);
assert_eq!(result.is_ok(), true);
let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
assert_eq!(claims.len(), 1);
let claim = claims.get(0).unwrap();
assert_eq!(claim.player_id, 1);
assert_eq!(claim.loot_id, 1);
// Claim an inexistant item
let result = DbApi::with_conn(&conn).as_player(1).claim(2);
assert_eq!(result.is_ok(), false);
}
#[test]
fn as_player_unclaim_item() {
let conn = test_connection();
DbApi::with_conn(&conn)
.as_admin()
.add_player("Player", 0.0)
.unwrap();
DbApi::with_conn(&conn)
.as_admin()
.add_loot(vec![("Épée", 25)])
.unwrap();
// Claim an existing item
let result = DbApi::with_conn(&conn).as_player(1).claim(1);
assert_eq!(result.is_ok(), true);
// Claiming twice is an error
let result = DbApi::with_conn(&conn).as_player(1).claim(1);
assert_eq!(result.is_ok(), false);
// Unclaiming and item
let result = DbApi::with_conn(&conn).as_player(1).unclaim(1);
assert_eq!(result.is_ok(), true);
// Check that not claimed items will not be unclaimed...
let result = DbApi::with_conn(&conn).as_player(1).unclaim(1);
assert_eq!(result.is_ok(), false);
let claims = DbApi::with_conn(&conn).fetch_claims().unwrap();
assert_eq!(claims.len(), 0);
}
/// All-in-one checks one a simple buy/sell procedure
///
/// Checks that player's chest and wealth are updated.
/// Checks that items are sold at half their value.
/// Checks that a player cannot sell item he does not own.
#[test]
fn as_player_simple_buy_sell() {
let conn = test_connection();
// Adds a sword into inventory
{
use schema::items::dsl::*;
diesel::insert_into(items)
.values((name.eq("Sword"), base_price.eq(800)))
.execute(&conn)
.expect("Could not set up items table");
}
DbApi::with_conn(&conn)
.as_admin()
.add_player("Player", 1000.0)
.unwrap();
// Buy an item
let bought = DbApi::with_conn(&conn).as_player(1).buy(&vec![(1, None)]);
assert_eq!(bought.ok(), Some((0, 0, 0, -8))); // Returns diff of player wealth ?
let chest = DbApi::with_conn(&conn).as_player(1).loot().unwrap();
assert_eq!(chest.len(), 1);
let loot = chest.get(0).unwrap();
assert_eq!(loot.name, "Sword");
assert_eq!(loot.base_price, 800);
let players = DbApi::with_conn(&conn).fetch_players().unwrap();
let player = players.get(1).unwrap();
assert_eq!(player.pp, 2);
// A player cannot sell loot from an other's chest
let result = DbApi::with_conn(&conn)
.as_player(0)
.sell(&vec![(loot.id, None)]);
assert_eq!(result.is_ok(), false);
// Sell back
let sold = DbApi::with_conn(&conn)
.as_player(1)
.sell(&vec![(loot.id, None)]);
assert_eq!(sold.ok(), Some((0, 0, 0, 4)));
let chest = DbApi::with_conn(&conn).as_player(1).loot().unwrap();
assert_eq!(chest.len(), 0);
let players = DbApi::with_conn(&conn).fetch_players().unwrap();
let player = players.get(1).unwrap();
assert_eq!(player.pp, 6);
}
#[test]
fn as_admin_add_loot() {
let conn = test_connection();
assert_eq!(
0,
DbApi::with_conn(&conn).as_player(0).loot().unwrap().len()
);
let loot_to_add = vec![("Cape d'invisibilité", 8000), ("Arc long", 25)];
let result = DbApi::with_conn(&conn)
.as_admin()
.add_loot(loot_to_add.clone());
assert_eq!(result.is_ok(), true);
let looted = DbApi::with_conn(&conn).as_player(0).loot().unwrap();
assert_eq!(looted.len(), 2);
// NB: Not a problem now, but this adds constraints of items being
// created in the same order.
for (added, to_add) in looted.into_iter().zip(loot_to_add) {
assert_eq!(added.name, to_add.0);
assert_eq!(added.base_price, to_add.1);
}
}
}

8
lootalot_db/src/models/claim.rs
View File

@@ -73,22 +73,22 @@ impl<'q> Claims<'q> {
.values(&claim)
.execute(self.0)?;
// Return the created claim
Ok(
Ok(vec!(
Update::ClaimAdded(
claims::table
.order(claims::dsl::id.desc())
.first::<Claim>(self.0)?
)
)
))
}
/// Removes a claim from database, returning it
pub fn remove(self, player_id: i32, loot_id: i32) -> UpdateResult {
let claim = self.find(player_id, loot_id)?;
claim.remove(self.0)?;
Ok(
Ok(vec!(
Update::ClaimRemoved(claim)
)
))
}
pub fn filtered_by_loot(&self, loot_id: i32) -> QueryResult<Vec<Claim>> {

14
lootalot_db/src/models/history.rs
View File

@@ -39,18 +39,14 @@ impl Event {
/// TODO: why a move here ??
/// Undo all updates in a single transaction
pub fn undo(self, conn: &DbConnection) -> QueryResult<UpdateList> {
pub fn undo(self, conn: &DbConnection) -> QueryResult<()> {
conn.transaction(move || {
if let Some(ref updates) = self.updates {
let undone = updates.0.iter()
// TODO: swallow errors !
.filter_map(|u| u.undo(conn, self.player_id).ok())
.collect();
diesel::delete(history::table.find(self.id)).execute(conn)?;
Ok(UpdateList(undone))
} else {
Ok(UpdateList(vec![]))
for update in updates.inner() {
update.undo(conn, self.player_id)?;
}
}
Ok(())
})
}
}

244
lootalot_db/src/models/item.rs
View File

@@ -2,10 +2,10 @@ use diesel::dsl::{exists, Eq, Filter, Find, Select};
use diesel::expression::exists::Exists;
use diesel::prelude::*;
use crate::schema::{items, looted, shop};
use crate::{DbConnection, QueryResult, Update, UpdateResult, Claims };
type ItemColumns = (looted::id, looted::name, looted::base_price);
const ITEM_COLUMNS: ItemColumns = (looted::id, looted::name, looted::base_price);
use crate::schema::{items, loot};
use crate::{Claims, DbConnection, QueryResult, Update, UpdateResult};
type ItemColumns = (loot::id, loot::name, loot::base_price);
const ITEM_COLUMNS: ItemColumns = (loot::id, loot::name, loot::base_price);
type OwnedBy = Select<OwnedLoot, ItemColumns>;
/// Represents a basic item
@@ -27,23 +27,58 @@ impl Item {
self.base_price as f64 / 2.0
}
pub fn remove(self, conn: &DbConnection) -> UpdateResult {
conn.transaction(
|| -> UpdateResult
{
Claims(conn).delete_for_loot(self.id)?;
diesel::delete(looted::table.find(self.id)).execute(conn)?;
Ok(Update::ItemRemoved(self))
}
)
}
fn owned_by(player: i32) -> OwnedBy {
Loot::owned_by(player).select(ITEM_COLUMNS)
}
}
// Owner status
pub(crate) const OF_GROUP: i32 = 0;
pub(crate) const OF_SHOP: i32 = -1;
pub(crate) const SOLD: i32 = -2;
type WithOwner = Eq<loot::owner_id, i32>;
type OwnedLoot = Filter<loot::table, WithOwner>;
/// An owned item
///
/// The owner is a Player, the Group, the Merchant
/// OR the SOLD state.
#[derive(Identifiable, Debug, Queryable)]
#[table_name = "loot"]
pub(crate) struct Loot {
id: i32,
name: String,
base_price: i32,
owner_id: i32,
}
impl Loot {
/// A filter on Loot that is owned by given player
pub(super) fn owned_by(id: i32) -> OwnedLoot {
loot::table.filter(loot::owner_id.eq(id))
}
pub(super) fn set_owner(&self, owner: i32, conn: &DbConnection) -> QueryResult<()> {
diesel::update(loot::table.find(self.id))
.set(loot::dsl::owner_id.eq(owner))
.execute(conn)?;
Ok(())
}
pub(super) fn into_item(self) -> Item {
Item {
id: self.id,
name: self.name,
base_price: self.base_price,
}
}
pub(super) fn find(id: i32) -> Find<loot::table, i32> {
loot::table.find(id)
}
}
pub struct Inventory<'q>(pub &'q DbConnection);
impl<'q> Inventory<'q> {
@@ -56,90 +91,93 @@ impl<'q> Inventory<'q> {
pub fn find(&self, item_id: i32) -> QueryResult<Item> {
items::table.find(item_id).first::<Item>(self.0)
}
pub fn find_by_name(&self, item_name: &str) -> QueryResult<Item> {
Ok(items::table
.filter(items::dsl::name.like(item_name))
.first(self.0)?)
}
/// Check the inventory against a list of item names
///
/// # Returns
///
/// A tuple of found items and errors
pub fn check_list(&self, item_names: Vec<String>) -> QueryResult<(Vec<Item>, String)> {
let all_items = self.all()?;
let mut found = Vec::new();
let mut errors = String::new();
for name in &item_names {
match self.find_by_name(name) {
Ok(item) => found.push(item),
Err(_) => errors.push_str(&format!("{},\n", name)),
}
}
Ok((found, errors))
}
}
/// The shop resource
pub struct Shop<'q>(pub &'q DbConnection);
impl<'q> Shop<'q> {
// Rename to list
pub fn all(&self) -> QueryResult<Vec<Item>> {
shop::table.load(self.0)
Item::owned_by(OF_SHOP).load(self.0)
}
pub fn get(&self, id: i32) -> QueryResult<Item> {
shop::table.find(&id).first::<Item>(self.0)
fn buy_single(&self, buyer: i32, item_id: i32, price_mod: Option<f64>) -> UpdateResult {
use crate::AsPlayer;
let item = self.get(item_id)?;
let sell_price = match price_mod {
Some(modifier) => item.base_price as f64 * modifier,
None => item.base_price as f64,
};
self.0.transaction(|| {
let mut updates = AsPlayer(self.0, buyer).update_wealth(-sell_price)?;
item.set_owner(buyer, self.0)?;
updates.push(Update::ItemBought(item.into_item()));
Ok(updates)
})
}
pub fn remove(&self, id: i32) -> QueryResult<()> {
diesel::delete(
shop::table.find(&id)
).execute(self.0)?;
Ok(())
pub fn buy(&self, items: Vec<(i32, Option<f64>)>, buyer: i32) -> UpdateResult {
// TODO: check that player has enough money !
let has_enough_gold = true;
if has_enough_gold {
let mut updates = Vec::new();
for (item_id, price_mod) in items.into_iter() {
updates.append(&mut self.buy_single(buyer, item_id, price_mod)?)
}
Ok(updates)
} else {
unimplemented!();
}
}
pub(crate) fn get(&self, id: i32) -> QueryResult<Loot> {
Loot::owned_by(OF_SHOP).find(&id).first::<Loot>(self.0)
}
pub fn replace_list(&self, items: Vec<Item>) -> QueryResult<()> {
self.0.transaction(
|| -> QueryResult<()>
{
use self::loot::dsl::*;
self.0.transaction(|| -> QueryResult<()> {
// Remove all content
diesel::delete(shop::table).execute(self.0)?;
diesel::delete(Loot::owned_by(OF_SHOP)).execute(self.0)?;
// Adds new list
for item in &items {
let new_item = NewItem {
let new_item = NewLoot {
name: &item.name,
base_price: item.base_price,
owner_id: OF_SHOP,
};
diesel::insert_into(shop::table)
diesel::insert_into(loot)
.values(&new_item)
.execute(self.0)?;
}
Ok(())
}
)
}
}
type WithOwner = Eq<looted::owner_id, i32>;
type OwnedLoot = Filter<looted::table, WithOwner>;
/// Represents an item that has been looted,
/// hence has an owner.
#[derive(Identifiable, Debug, Queryable)]
#[table_name = "looted"]
pub(super) struct Loot {
id: i32,
name: String,
base_price: i32,
owner: i32,
}
impl Loot {
/// A filter on Loot that is owned by given player
pub(super) fn owned_by(id: i32) -> OwnedLoot {
looted::table.filter(looted::owner_id.eq(id))
}
fn exists(id: i32) -> Exists<Find<looted::table, i32>> {
exists(looted::table.find(id))
}
pub(super) fn set_owner(&self, owner: i32, conn: &DbConnection) -> QueryResult<()> {
diesel::update(looted::table.find(self.id))
.set(looted::dsl::owner_id.eq(owner))
.execute(conn)?;
Ok(())
}
pub(super) fn into_item(self) -> Item {
Item {
id: self.id,
name: self.name,
base_price: self.base_price,
}
}
pub(super) fn find(id: i32) -> Find<looted::table, i32> {
looted::table.find(id)
})
}
}
@@ -152,28 +190,50 @@ impl<'q> LootManager<'q> {
Ok(Item::owned_by(self.1).load(self.0)?)
}
pub(crate) fn get(&self, item_id: i32) -> QueryResult<Loot> {
Ok(Loot::owned_by(self.1).find(item_id).first(self.0)?)
}
pub(crate) fn change_owner(&self, item_id: i32, new_owner: i32) -> QueryResult<()> {
Ok(self.get(item_id)?.set_owner(new_owner, self.0)?)
}
/// Finds an item by id
///
/// Returns a NotFound error if an item is found by it
/// does not belong to this player
pub fn find(&self, loot_id: i32) -> QueryResult<Item> {
Ok(Loot::find(loot_id).first(self.0).and_then(|loot: Loot| {
if loot.owner != self.1 {
Err(diesel::result::Error::NotFound)
} else {
Ok(Item {
id: loot.id,
name: loot.name,
base_price: loot.base_price,
Ok(self.get(loot_id)?.into_item())
}
fn sell_single(&self, loot_id: i32, price_mod: Option<f64>) -> UpdateResult {
let to_sell = self.get(loot_id)?;
let mut sell_value = to_sell.base_price as f64 / 2.0;
if let Some(modifier) = price_mod {
sell_value *= modifier;
}
self.0.transaction(|| {
let mut updates = crate::AsPlayer(self.0, self.1).update_wealth(sell_value)?;
to_sell.set_owner(SOLD, self.0)?;
updates.push(Update::ItemSold(to_sell.into_item()));
Ok(updates)
})
}
})?)
pub fn sell(&self, items: Vec<(i32, Option<f64>)>) -> UpdateResult {
self.0.transaction(|| {
let mut updates = Vec::new();
for (loot_id, price_mod) in items.into_iter() {
updates.append(&mut self.sell_single(loot_id, price_mod)?);
}
Ok(updates)
})
}
/// The last item added to the chest
pub fn last(&self) -> QueryResult<Item> {
Ok(Item::owned_by(self.1)
.order(looted::dsl::id.desc())
.order(loot::dsl::id.desc())
.first(self.0)?)
}
@@ -192,19 +252,19 @@ impl<'q> LootManager<'q> {
base_price: item.base_price,
owner_id: self.1,
};
diesel::insert_into(looted::table)
diesel::insert_into(loot::table)
.values(&new_item)
.execute(self.0)?;
Ok(Update::ItemAdded(self.last()?))
Ok(vec![Update::ItemAdded(self.last()?)])
}
}
/// An item being looted or bought.
/// An item being loot or bought.
///
/// The owner is set to 0 in case of looting,
/// to the id of buying player otherwise.
#[derive(Insertable)]
#[table_name = "looted"]
#[table_name = "loot"]
struct NewLoot<'a> {
name: &'a str,
base_price: i32,
@@ -212,7 +272,7 @@ struct NewLoot<'a> {
}
#[derive(Insertable)]
#[table_name = "shop"]
#[table_name = "items"]
struct NewItem<'a> {
name: &'a str,
base_price: i32,

2
lootalot_db/src/models/player/mod.rs
View File

@@ -89,7 +89,7 @@ impl<'q> AsPlayer<'q> {
.filter(id.eq(self.1))
.set(&updated_wealth)
.execute(self.0)?;
Ok(Update::Wealth(updated_wealth - current_wealth))
Ok(vec!(Update::Wealth(updated_wealth - current_wealth)))
}
/// Updates this player's debt

16
lootalot_db/src/schema.rs
View File

@@ -26,7 +26,7 @@ table! {
}
table! {
looted (id) {
loot (id) {
id -> Integer,
name -> Text,
base_price -> Integer,
@@ -54,26 +54,16 @@ table! {
}
}
table! {
shop (id) {
id -> Integer,
name -> Text,
base_price -> Integer,
}
}
joinable!(claims -> looted (loot_id));
joinable!(claims -> players (player_id));
joinable!(history -> players (player_id));
joinable!(looted -> players (owner_id));
joinable!(loot -> players (owner_id));
joinable!(notifications -> players (player_id));
allow_tables_to_appear_in_same_query!(
claims,
history,
items,
looted,
loot,
notifications,
players,
shop,
);

2
lootalot_front/.browserslistrc
View File

@@ -1,2 +0,0 @@
> 1%
last 2 versions

27
lootalot_front/.eslintrc.js
View File

@@ -1,27 +0,0 @@
module.exports = {
root: true,
env: {
node: true
},
'extends': [
'plugin:vue/essential',
'eslint:recommended'
],
rules: {
'no-console': process.env.NODE_ENV === 'production' ? 'error' : 'off',
'no-debugger': process.env.NODE_ENV === 'production' ? 'error' : 'off'
},
parserOptions: {
parser: 'babel-eslint'
},
overrides: [
{
files: [
'**/__tests__/*.{j,t}s?(x)'
],
env: {
mocha: true
}
}
]
}

21
lootalot_front/.gitignore vendored
View File

@@ -1,21 +0,0 @@
.DS_Store
node_modules
/dist
# local env files
.env.local
.env.*.local
# Log files
npm-debug.log*
yarn-debug.log*
yarn-error.log*
# Editor directories and files
.idea
.vscode
*.suo
*.ntvs*
*.njsproj
*.sln
*.sw?

29
lootalot_front/README.md
View File

@@ -1,29 +0,0 @@
# lootalot_front
## Project setup
```
npm install
```
### Compiles and hot-reloads for development
```
npm run serve
```
### Compiles and minifies for production
```
npm run build
```
### Run your tests
```
npm run test
```
### Lints and fixes files
```
npm run lint
```
### Customize configuration
See [Configuration Reference](https://cli.vuejs.org/config/).

5
lootalot_front/babel.config.js
View File

@@ -1,5 +0,0 @@
module.exports = {
presets: [
'@vue/app'
]
}

29
lootalot_front/package.json
View File

@@ -1,29 +0,0 @@
{
"name": "lootalot_front",
"version": "0.1.0",
"private": true,
"scripts": {
"serve": "vue-cli-service serve",
"build": "vue-cli-service build",
"lint": "vue-cli-service lint",
"test:unit": "vue-cli-service test:unit"
},
"main": "sass/scroll.scss",
"dependencies": {
"bulma": "^0.7.5",
"core-js": "^2.6.5",
"vue": "^2.6.10"
},
"devDependencies": {
"@vue/cli-plugin-babel": "^3.11.0",
"@vue/cli-plugin-eslint": "^3.11.0",
"@vue/cli-plugin-unit-mocha": "^3.11.0",
"@vue/cli-service": "^3.11.0",
"@vue/test-utils": "1.0.0-beta.29",
"babel-eslint": "^10.0.1",
"chai": "^4.1.2",
"eslint": "^5.16.0",
"eslint-plugin-vue": "^5.0.0",
"vue-template-compiler": "^2.6.10"
}
}

5
lootalot_front/postcss.config.js
View File

@@ -1,5 +0,0 @@
module.exports = {
plugins: {
autoprefixer: {}
}
}

6957
lootalot_front/public/css/scroll.css
View File

File diff suppressed because it is too large Load Diff

BIN
lootalot_front/public/favicon.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.2 KiB

20
lootalot_front/public/index.html
View File

@@ -1,20 +0,0 @@
<!DOCTYPE HTML>
<html>
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<link rel="icon" href="<%= BASE_URL %>favicon.ico">
<link rel="stylesheet" href="<%= BASE_URL %>css/scroll.css">
<title>Loot-a-Lot !</title>
<script defer src="<%= BASE_URL %>fontawesome/js/all.js"></script>
</head>
<body>
<div id="app"></div>
<!-- built files will be auto injected -->
<noscript>
<strong>We're sorry but lootalot_front doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
</noscript>
</body>
</html>

21
lootalot_front/sass/scroll.scss
View File

@@ -1,21 +0,0 @@
@charset "utf-8";
$brown: #757763;
$beige: #C9AD6A;
$beige-light: #E0E5C1;
$beige-lighter: #EEE5CE;
$red: #B7321B;
$dark-red: #58180D;
$yellow-light: #FCF2C5;
$link: $brown;
$primary: $brown;
$info: $beige;
$danger: $red;
$table-cell-border: 1px solid $dark-red;
$table-striped-row-even-background-color: $yellow-light;
$button-padding-horizontal: 1em;
@import "../node_modules/bulma/bulma.sass";

190
lootalot_front/src/App.vue
View File

@@ -1,190 +0,0 @@
<template>
<PlayerView
:id="player_id"
:players="playersId"
v-slot="{ player, loot, notifications, actions, claims }"
>
<main id="app" class="container">
<header>
<HeaderBar>
<template v-slot:title>
{{ player.name }}
</template>
<template v-slot:links>
<a class="navbar-item">History of Loot</a>
<template v-if="playerIsGroup">
<hr class="navbar-divider">
<div class="navbar-item heading">Admin</div>
<a class="navbar-item">"Resolve claims"</a>
<a class="navbar-item">"Add player"</a>
</template>
<hr class="navbar-divider">
<div class="navbar-item heading">Changer</div>
<a v-for="(p,i) in playerList" :key="i"
@click="setActivePlayer(i)"
href="#" class="navbar-item">
{{ p.name }}</a>
</template>
</HeaderBar>
<Wealth
:wealth="[player.cp, player.sp, player.gp, player.pp]"
:debt="player.debt"
@update="actions.updateWealth"
></Wealth>
<p v-show="notifications.length > 0">{{ notifications }}</p>
<button class="button" @click="actions.undoLastAction">Annuler action</button>
</header>
<nav>
<div class="tabs is-centered is-boxed is-medium">
<ul>
<li :class="{ 'is-active': activeView == 'group' }">
<a @click="switchView('group')">
Coffre de groupe
</a>
</li>
<li v-show="!playerIsGroup" :class="{ 'is-active': activeView == 'player' }">
<a @click="switchView('player')">
Mon coffre
</a>
</li>
<li :class="{'is-active': activeView == 'adding' }">
<a class="has-text-grey-light"
@click="switchView('adding')">
+ {{ playerIsGroup ? 'Nouveau Loot' : 'Acheter' }}
</a>
</li>
</ul>
</div>
</nav>
<main class="section">
<template v-if="isAdding">
<Loot v-if="playerIsGroup"
:inventory="itemsInventory"
@addItem="item => pending_loot.push(item)"
@confirmAction="addNewLoot"
></Loot>
<AddingChest
:player="player.id"
:claims="claims"
:items="playerIsGroup ? pending_loot : itemsInShop"
:perms="playerIsGroup ? {} : { canBuy: true }"
@buy="(data) => { switchView('player'); actions.buyItems(data); }">
</AddingChest>
</template>
<Chest v-else
:player="player.id"
:claims="claims"
:items="showPlayerChest ? loot : groupLoot"
:perms="{
canGrab: !(showPlayerChest || playerIsGroup),
canSell: showPlayerChest || playerIsGroup
}"
@sell="actions.sellItems"
@claim="actions.putClaim"
@unclaim="actions.withdrawClaim">
</Chest>
</main>
</main>
</PlayerView>
</template>
<script>
import PlayerView from './components/PlayerView.js'
import HeaderBar from './components/HeaderBar.vue'
import Wealth from './components/Wealth.vue'
import Chest from './components/Chest.vue'
import Loot from './components/Loot.vue'
import { api } from './lootalot.js'
function getCookie(cname) {
var name = cname + "=";
var decodedCookie = decodeURIComponent(document.cookie);
var ca = decodedCookie.split(';');
for(var i = 0; i <ca.length; i++) {
var c = ca[i];
while (c.charAt(0) == ' ') {
c = c.substring(1);
}
if (c.indexOf(name) == 0) {
return c.substring(name.length, c.length);
}
}
return "";
}
export default {
name: 'app',
data () {
return {
player_id: 0,
playerList: [],
activeView: 'group',
groupLoot: [],
itemsInventory: [],
itemsInShop: [{id: 1, name: "Item from shop #1", base_price: 2000}],
pending_loot: [],
initiated: false,
};
},
components: {
PlayerView,
HeaderBar,
'AddingChest': Chest, // Alias to prevent component re-use
Chest,
Wealth,
Loot,
},
created () {
const cookie = getCookie("player_id");
this.player_id = cookie ? Number(cookie) : 0;
Promise.all([
api.fetch("players/", "GET", null),
api.fetch("players/0/loot", "GET", null),
api.fetch("items", "GET", null),
])
.then(([players, loot, items]) => {
this.$set(this, 'playerList', players.value);
this.groupLoot = loot.value;
this.itemsInventory = items.value;
})
.catch(r => alert("Error ! \n" + r))
.then(() => this.initiated = true);
},
methods: {
setActivePlayer (idx) {
if (idx == 0) this.switchView('group');
this.player_id = Number(idx)
document.cookie = `player_id=${idx};`;
},
switchView (viewId) {
if (!['group', 'player', 'adding'].includes(viewId)) {
console.error("Not a valid view ID :", viewId);
}
this.activeView = viewId;
},
addNewLoot () {
api.fetch("players/0/loot", "POST", {
source_name: "Dummy name",
items: this.pending_loot,
})
.then(() => {
this.pending_loot = []
this.switchView('group');
})
.catch(r => alert("Error: " + r));
}
},
computed: {
showPlayerChest () { return this.activeView == 'player' },
isAdding () { return this.activeView == 'adding' },
playerIsGroup () { return this.player_id == 0 },
playersId () { return this.playerList.map(p => p.id).filter(i => i != 0); }
}
}
</script>
<style scoped>
header {
padding-bottom: 1.5em;
}
</style>

BIN
lootalot_front/src/assets/logo.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 6.7 KiB

166
lootalot_front/src/components/Chest.vue
View File

@@ -1,166 +0,0 @@
<template>
<article>
<p class="control has-icons-left">
<input type="text" class="input" v-model="searchText">
<span class="icon is-small is-left"><i class="fas fa-search"></i></span>
</p>
<table class="table is-fullwidth is-striped">
<thead>
<tr>
<th width="100%">Objets</th>
<th>Valeur</th>
<th>
<div v-if="perms.canSell" class="buttons" :class="{'has-addons': is_selling}">
<button class="button"
:class="is_selling ? 'is-danger' : 'is-warning'"
@click="sellSelectedItems"
>
<span class="icon">
<i class="fas fa-coins"></i>
</span>
<p v-if="!is_selling">Vendre</p>
<p v-else>{{ selected_items.length > 0 ? `${totalSelectedValue} po` : 'Annuler' }}</p>
</button>
<PercentInput v-show="is_selling" v-model="global_mod"></PercentInput>
</div>
<div v-else-if="perms.canBuy">
<button class="button is-danger is-fullwidth"
:disabled="selected_items.length == 0"
@click="buySelectedItems"
>Acheter ({{ totalSelectedValue}}po)</button>
</div>
<div v-else-if="perms.canGrab">
<button class="button is-static is-fullwidth">Demander</button>
</div>
</th>
</tr>
</thead>
<tbody>
<template v-for="(item, idx) in shownItems">
<tr :key="`row-${idx}`">
<td>
<strong>{{item.name}}</strong>
</td>
<td>
{{ is_selling ? item.base_price / 2 : item.base_price }}po
</td>
<td>
<Request
v-if="perms.canGrab"
:id="player"
:claims="claims"
:item="item.id"
@claim="(data) => $emit('claim', data)"
@unclaim="(data) => $emit('unclaim', data)"
></Request>
<Selector
v-else-if="showSelectors"
:id="item.id"
v-model="selected_items"
></Selector>
</td>
</tr>
</template>
</tbody>
</table>
</article>
</template>
<script>
import Request from './Request.vue'
import PercentInput from './PercentInput.vue'
import Selector from './Selector.vue'
import { api } from '../lootalot.js'
/*
The chest displays a collection of items.
A set of permissions is passed as props, to update
the possible actions of active user upon these items.
*/
export default {
props: {
player: {
type: Number,
required: true,
},
items: {
type: Array,
required: true,
},
perms: {
type: Object,
required: true,
},
claims: {
type: Object,
required: true,
},
},
components: {
Request,
PercentInput,
Selector,
},
data () {
return {
is_selling: false,
selected_items: [],
global_mod: 0,
searchText: "",
};
},
methods: {
buySelectedItems () {
this.$emit("buy", this.selected_items);
this.selected_items = [];
},
sellSelectedItems () {
if (!this.is_selling) {
this.is_selling = true;
} else {
this.is_selling = false;
if (this.selected_items.length > 0) {
this.$emit("sell", this.selected_items);
this.selected_items = [];
}
}
},
},
computed: {
shownItems () {
if (this.searchText != "") {
const searchText = this.searchText.toUpperCase();
return this.items.filter(item => item.name.toUpperCase().includes(searchText));
} else {
return this.items;
}
},
showSelectors () {
return !this.perms.canGrab
&& (this.is_selling || this.perms.canBuy);
},
totalSelectedValue () {
var total = this.selected_items
.map(([id, mod]) => {
const item = this.items.find(item => item.id == id);
var price = item.base_price * mod;
if (this.is_selling) {
price = price / 2;
}
return price;
})
.reduce((total,value) => total + value, 0);
return (1 + this.global_mod / 100) * total;
},
},
}
</script>
<style scoped>
.table td, .table th { vertical-align: middle; }
.buttons { flex-wrap: nowrap; }
label.is-checkbox {
background-color: #eee;
}
</style>

36
lootalot_front/src/components/HeaderBar.vue
View File

@@ -1,36 +0,0 @@
<template>
<nav class="navbar is-info">
<div class="navbar-brand">
<p class="navbar-item is-size-4"><slot name="title">...</slot></p>
<a role="button" class="navbar-burger" aria-label="menu" aria-expanded="false"
@click="switchMobileVisibility">
<span aria-hidden="true"></span>
<span aria-hidden="true"></span>
<span aria-hidden="true"></span>
</a>
</div>
<div id="menu" class="navbar-menu" :class="{'is-active': showOnMobile }">
<div class="navbar-end">
<div class="navbar-item has-dropdown is-hoverable">
<a class="navbar-link">Autres</a>
<div class="navbar-dropdown is-right" @click="switchMobileVisibility">
<slot name="links">
<a class="navbar-item">History of Loot</a>
</slot>
</div>
</div>
</div>
</div>
</nav>
</template>
<script>
export default {
data () { return { showOnMobile: false } },
methods: {
switchMobileVisibility () {
this.showOnMobile = !this.showOnMobile
}
}
}
</script>

109
lootalot_front/src/components/ItemInput.vue
View File

@@ -1,109 +0,0 @@
<template>
<div class="field is-horizontal">
<div class="field-label">
<label class="label">Nouvel objet</label>
</div>
<div class="field-body">
<div class="field">
<div class="control is-expanded">
<input type="text"
name="name"
placeholder="Nom de l'objet"
v-model="item.name"
@input="autoCompletion"
class="input"
autocomplete="on"
>
</div>
<div class="dropdown" :class="{'is-active': showCompletionFrame}">
<div class="dropdown-menu">
<div class="dropdown-content">
<a v-for="(result,i) in results"
:key="i"
@click="setResult(result)"
class="dropdown-item"
>{{ result.name }}</a>
</div>
</div>
</div>
</div>
<div class="field is-expanded has-addons" v-show="item.name != ''">
<p class="control"><a class="button is-static">PO</a></p>
<p class="control">
<input type="text"
name="base_price"
placeholder="Prix"
class="input"
:class="{'is-danger': item.base_price == ''}"
v-model.number="item.base_price"
>
</p>
</div>
<div class="field">
<div class="control">
<button class="button is-primary"
@click="addItem"
:disabled="!isItemValid"
>Ajouter</button>
</div>
</div>
</div>
</div>
</template>
<script>
export default {
props: ["source"],
data () {
return {
is_loading: false,
item: {
id: 0,
name: '',
base_price: '',
},
results: [],
};
},
methods: {
autoCompletion () {
// Unset any previous value on input (for every field except item's name)
this.item.base_price = '';
if (this.item.name == '') {
this.results = [];
} else {
this.results = this.source.filter(
item => item.name.toUpperCase().includes(this.item.name.toUpperCase())
);
}
},
setResult(result) {
this.item.id = result.id;
this.item.name = result.name;
this.item.base_price = result.base_price;
// Clear results to close completionFrame
this.results = [];
},
addItem () {
this.$emit("addItem", this.item);
this.item = {
name: '',
base_price: '',
};
this.results = [];
},
},
computed: {
showCompletionFrame () { return this.results.length > 0 },
isItemValid () { return this.item.name != '' && this.item.base_price != '' },
}
}
</script>
<style scoped>
.dropdown, .dropdown-menu {
min-width: 100%;
margin-top: 0;
padding-top: 0;
}
</style>

35
lootalot_front/src/components/Loot.vue
View File

@@ -1,35 +0,0 @@
<template>
<div class="box">
<ItemInput
@addItem="onAddItem"
:source="inventory"
></ItemInput>
<div class="field is-horizontal">
<div class="field-label"><label class="label">ou</label></div>
<div class="field-body">
<div class="field">
<div class="control">
<button class="button is-primary">Depuis une liste</button>
</div>
</div>
</div>
</div>
<button class="button is-danger" @click="$emit('confirmAction')">Finaliser</button>
</div>
</template>
<script>
import ItemInput from './ItemInput.vue'
export default {
props: ["inventory"],
components: { ItemInput },
data () { return {}; },
methods: {
onAddItem (item) {
this.$emit('addItem', item);
},
}
}
</script>

41
lootalot_front/src/components/PercentInput.vue
View File

@@ -1,41 +0,0 @@
<template>
<div class="field has-addons">
<div v-show="is_opened" class="control has-icons-left">
<input class="input" :value="value" @input="input" type="number" size="3" min="-50" max=50 step=5>
<span class="icon is-left">
<i class="fas fa-percent"></i>
</span>
</div>
<div class="control">
<button class="button" @click="switchOpenedState">
<small v-if="!is_opened">Mod.</small>
<span v-else class="icon"><i class="fas fa-times-circle"></i></span>
</button>
</div>
</div>
</template>
<script>
export default {
props: ["value"],
data () {
return {
is_opened: false,
};
},
methods: {
input (event) { this.$emit("input", event.target.value); },
switchOpenedState () {
this.is_opened = !this.is_opened;
// Reset the modifier in closed state
if (!this.is_opened) {
this.$emit("input", 0);
}
}
}
}
</script>
<style scoped>
.input { width: 6em; }
</style>

118
lootalot_front/src/components/PlayerView.js
View File

@@ -1,118 +0,0 @@
import { api } from '../lootalot.js'
export default {
props: ["id", "players"],
data () { return {
player: {
name: "Loading",
id: 0,
cp: '-', sp: '-', gp: '-', pp: '-',
debt: 0,
},
notifications: [],
loot: [],
claims: {},
}},
created () {
api.fetch("claims", "GET", null)
.then(r => {
for (var idx in r.value) {
var claim = r.value[idx];
if (!(claim.player_id in this.claims)) {
this.$set(this.claims, claim.player_id, []);
}
this.claims[claim.player_id].push(claim.loot_id);
}
});
},
methods: {
parseUpdate (update) {
if (update.Wealth) {
var w = update.Wealth;
this.player.cp += w.cp;
this.player.sp += w.sp;
this.player.gp += w.gp;
this.player.pp += w.pp;
}
else if (update.ItemAdded) {
var i = update.ItemAdded;
this.loot.push(i);
}
else if (update.ItemRemoved) {
var removed = update.ItemRemoved;
var idx = this.loot.findIndex(item => item.id == removed.id);
this.loot.splice(idx, 1);
}
else if (update.ClaimAdded) {
var c = update.ClaimAdded;
this.claims[c.player_id].push(c.loot_id);
}
else if (update.ClaimRemoved) {
var c = update.ClaimRemoved;
this.claims[c.player_id].splice(
this.claims[c.player_id].indexOf(c.loot_id),
1
);
}
},
call (resource, method, payload) {
return api.fetch(`players/${this.id}/${resource}`, method, payload)
.then(response => {
if (response.notification) {
this.notifications.push(response.notification)
}
if (response.errors) {
this.notifications.push(response.errors)
}
if (response.updates) {
for (var idx in response.updates) {
this.parseUpdate(response.updates[idx]);
}
}
return response.value;
})
},
updateWealth (value) { this.call("wealth", "PUT", Number(value)) },
putClaim (itemId) { this.call("claims", "PUT", itemId) },
withdrawClaim (itemId) { this.call("claims", "DELETE", itemId) },
buyItems(items) { this.call("loot", "PUT", items) },
sellItems (items) {
let players;
if (this.player.id == 0) {
players = this.players;
} else {
players = null;
}
this.call("loot", "DELETE", { items, global_mod: null, players })
},
undoLastAction () { this.call("events/last", "DELETE", null) },
},
watch: {
id: {
immediate: true,
handler: function(newId) {
this.call("", "GET", null)
.then(p => this.player = p)
this.call("loot", "GET", null)
.then(l => this.loot = l)
}
},
},
computed: {},
render () {
return this.$scopedSlots.default({
player: this.player,
loot: this.loot,
notifications: this.notifications,
actions: {
updateWealth: this.updateWealth,
putClaim: this.putClaim,
withdrawClaim: this.withdrawClaim,
buyItems: this.buyItems,
sellItems: this.sellItems,
undoLastAction: this.undoLastAction,
},
claims: this.claims,
})
}
}

92
lootalot_front/src/components/Request.vue
View File

@@ -1,92 +0,0 @@
<template>
<div class="buttons">
<template v-if="isInConflict">
<button class="button is-success"
@click="cancelRequest">
<span class="icon is-small">
<i class="fas fa-hand-peace"></i>
</span>
</button>
<button class="button is-danger"
@click="hardenRequest">
<span class="icon is-small">
<i class="fas fa-hand-middle-finger"></i>
</span>
</button>
</template>
<button class="button is-primary"
@click="putRequest"
:disabled="isRequested">
<span class="icon is-small">
<i class="fas fa-praying-hands"></i>
</span>
</button>
</div>
</template>
<script>
export default {
props: {
// Id of active player
id: {
type: Number,
required: true,
},
// Map of all claims
claims: {
type: Object,
required: true,
},
// Id of item we are bound to
item: {
type: Number,
required: true,
}
},
computed: {
// Check if item is requested by active player
isRequested () {
if (this.claims[this.id]) {
return this.claims[this.id].includes(this.item);
} else {
return false;
}
},
// Check if item is requested by multiple players including active one
isInConflict () {
var reqByPlayer = false;
var reqByOther = false;
for (var id in this.claims) {
const isReq = this.claims[id].includes(this.item);
if (isReq) {
if (id == this.id) {
reqByPlayer = true;
} else {
reqByOther = true;
}
}
}
return reqByPlayer && reqByOther;
},
},
methods: {
// The active player claims the item
putRequest () {
this.$emit("claim", this.item);
},
// The active player withdraws his request
cancelRequest () {
this.$emit("unclaim", this.item);
},
// The active player insist on his claim
// TODO: Find a simple and fun system to express
// how much each player want an item
hardenRequest () {
}
},
}
</script>
<style scoped>
.buttons, .button { margin-bottom: 0; }
</style>

57
lootalot_front/src/components/Selector.vue
View File

@@ -1,57 +0,0 @@
<template>
<div class="buttons has-addons">
<label class="button is-fullwidth">
<input type="checkbox" class="checkbox" v-model="selected">
</label>
<PercentInput v-show="selected" v-model.number="mod_value"></PercentInput>
</div>
</template>
<script>
import PercentInput from './PercentInput.vue'
/* Selector for a specific item, with an associated price modifier.
Acts as checkbox on a v-model, except it populates an array with [value, modifier] instead of value alone
*/
export default {
props: ["id", "value"],
components: { PercentInput },
data () {
return {
selected: false,
mod_value: 0,
};
},
computed: {
modifier () {
return 1 + this.mod_value / 100;
}
},
watch: {
selected (newState) {
let idx = this._findData();
var updated = this.value;
if (newState == true && idx == -1) {
updated.push([this.id, this.modifier]);
} else if (newState == false && idx != -1 ) {
updated.splice(idx, 1);
}
this.$emit('input', updated);
},
mod_value (newState) {
let idx = this._findData();
var updated = this.value;
if (idx != -1) {
updated.splice(idx, 1, [this.id, this.modifier]);
this.$emit('input', updated);
}
}
},
methods: {
_findData () {
return this.value.findIndex(([val,mod]) => this.id == val);
}
}
}
</script>

97
lootalot_front/src/components/Wealth.vue
View File

@@ -1,97 +0,0 @@
<template>
<section class="level is-mobile">
<div class="level-left">
<div class="level-item">
<span class="icon is-large" @click="editing = !editing">
<i class="fas fa-2x fa-piggy-bank"></i>
</span>
</div>
<template v-if="editing">
<div class="level-item">
<div class="field has-addons">
<p class="control">
<input class="input" type="number" step="0.01" v-model="edit_value"></input>
</p>
<p class="control">
<a class="button is-static">po</a>
</p>
</div>
</div>
<div class="level-item">
<button class="button is-danger" @click="updateWealth()">
Modifier
</button>
</div>
</template>
<template v-else>
<div class="level-item ">
<p class="is-size-4">{{ pp }}</p>
<p class="heading">PP</p>
</div>
<div class="level-item ">
<p class="is-size-4">{{ gp }}</p>
<p class="heading">PO</p>
</div>
<div class="level-item ">
<p class="is-size-4 has-text-grey-light">{{ sp }}</p>
<p class="heading">PA</p>
</div>
<div class="level-item ">
<p class="is-size-4 has-text-grey-light">{{ cp }}</p>
<p class="heading">PC</p>
</div>
</template>
</div>
<div class="level-right" v-if="debt">
<div class="level-item">
<p class="heading is-size-4 has-text-danger">Dette: {{ debt }}gp </p>
</div>
</div>
</div>
</section>
</template>
<script>
export default {
props: ["wealth", "debt"],
data () {
return {
editing: false,
edit_value: 0,
};
},
methods: {
updateWealth () {
this.$emit("update", this.edit_value);
this.resetValues();
},
resetValues () {
this.editing = false;
this.edit_value = 0;
}
},
computed: {
pp () {
return this.wealth[3];
},
gp () {
const gp = this.wealth[2];
if (gp < 10) {
return "0" + gp;
} else {
return gp;
}
},
sp () {
return this.wealth[1];
},
cp () {
return this.wealth[0];
},
}
}
</script>
<style scoped>
.input { max-width: 9em; }
</style>

20
lootalot_front/src/lootalot.js
View File

@@ -1,20 +0,0 @@
const API_BASEURL = "http://localhost:8088/api/"
const API_ENDPOINT = function (tailString) {
return API_BASEURL + tailString;
}
export const api = {
fetch: function(endpoint, method, payload) {
var config = {
method,
headers: {
'Content-Type': 'application/json',
},
};
if (payload) {
config.body = JSON.stringify(payload);
}
return fetch(API_ENDPOINT(endpoint), config)
.then(r => r.json());
}
}

8
lootalot_front/src/main.js
View File

@@ -1,8 +0,0 @@
import Vue from 'vue'
import App from './App.vue'
Vue.config.productionTip = false
new Vue({
render: h => h(App),
}).$mount('#app')

5
lootalot_front/tests/unit/.eslintrc.js
View File

@@ -1,5 +0,0 @@
module.exports = {
env: {
mocha: true
}
}

94
lootalot_front/tests/unit/ItemInput.spec.js
View File

@@ -1,94 +0,0 @@
import { expect } from 'chai'
import { mount } from '@vue/test-utils'
import ItemInput from '@/components/ItemInput.vue'
const MOCK_SOURCE = [
{ id: 1, name: "Épée", base_price: 20 },
{ id: 2, name: "Arc", base_price: 30 },
]
const withItemFactory = function (item) {
const wrapper = mount(ItemInput, {
propsData: {
source: MOCK_SOURCE,
}
})
wrapper.setData({ item })
return wrapper
}
describe('ItemInput.vue', () => {
// Tests on validation of the item data
it('item with name and price is valid', () => {
const localItem = {
item: {
id: 0,
name: 'Epee',
base_price: 200
}
}
expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(true)
})
it('item without data is not valid', () => {
const localItem = {
item: {
id: 0,
name: '',
base_price: ''
}
}
expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(false)
})
it('item without price is not valid', () => {
const localItem = {
item: {
id: 0,
name: 'Epee',
base_price: ''
}
}
expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(false)
})
it('item without name is not valid', () => {
const localItem = {
item: {
id: 0,
name: '',
base_price: 200
}
}
expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(false)
})
it('item price must be a number', () => {
const localItem = {
item: {
id: 0,
name: 'Epee',
base_price: 'cheap'
}
}
expect(ItemInput.computed.isItemValid.call(localItem)).to.equal(false)
})
// Test on auto-completion
it('show completion suggestions on input', () => {
const wrapper = withItemFactory({ id: 0, name: '', base_price: '' })
const input = wrapper.find({ name: "name" })
const suggestionBox = wrapper.find('.dropdown')
console.log(input)
expect(suggestionBox.classes('is-active')).to.equal(true)
})
it('hides suggestion box when no suggestions are available', () => {
})
it('click on suggestion sets the item', () => {
})
})

14
lootalot_front/tests/unit/Wealth.spec.js
View File

@@ -1,14 +0,0 @@
import { expect } from 'chai'
import { shallowMount } from '@vue/test-utils'
import Wealth from '@/components/Wealth.vue'
describe('Wealth.vue', () => {
it('renders wealth when passed', () => {
const wealth = [1, 2, 3, 4]
const wrapper = shallowMount(Wealth, {
propsData: { wealth }
})
var divs = wrapper.findAll('div')
expect(wrapper.text()).to.include(wealth)
})
})

275
src/api.rs
View File

@@ -16,9 +16,16 @@ pub struct BuySellParams {
#[derive(Serialize, Deserialize, Debug)]
pub struct NewGroupLoot {
source_name: String,
// claims_limit_date: String
pub items: ItemList,
}
#[derive(Serialize, Deserialize, Debug)]
pub struct NewPlayer {
name : String,
wealth : f64,
}
/// A generic response for all queries
#[derive(Serialize, Debug, Default)]
pub struct ApiResponse {
@@ -33,14 +40,18 @@ pub struct ApiResponse {
}
impl ApiResponse {
fn push_update(&mut self, update: db::Update) {
fn push_updates(&mut self, mut updates: Vec<db::Update>) {
if let Some(v) = self.updates.as_mut() {
v.push(update);
v.append(&mut updates);
} else {
self.updates = Some(vec![update]);
self.updates = Some(updates);
}
}
fn push_update(&mut self, update: db::Update) {
self.push_updates(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());
@@ -63,189 +74,145 @@ pub enum ApiError {
InvalidAction(String),
}
/// Every allowed queries on the database
pub enum ApiActions {
// Application level
FetchPlayers,
FetchInventory,
FetchShopInventory,
FetchClaims,
CheckItemList(Vec<String>),
// Player level
FetchPlayer(i32),
FetchPlayerClaims(i32),
FetchNotifications(i32),
FetchLoot(i32),
UpdateWealth(i32, f64),
BuyItems(i32, BuySellParams),
SellItems(i32, BuySellParams),
ClaimItems(i32, IdList),
ClaimItem(i32, i32),
UnclaimItem(i32, i32),
UndoLastAction(i32),
// Group level
AddLoot(NewGroupLoot),
// Admin level
RefreshShopInventory(ItemList),
//AddPlayer(String, f64),
//AddInventoryItem(pub String, pub i32),
//ResolveClaims,
//SetClaimsTimeout(pub i32),
pub enum ApiEndpoint {
InventoryList,
InventoryCheck(Vec<String>),
InventoryAdd(String, i32), // db::Inventory(conn)::add(new_item)
ShopList, // db::Shop(conn)::list()
BuyItems(i32, BuySellParams), // db::Shop(conn)::buy(params)
RefreshShop(ItemList), // db::Shop(conn)::replace_list(items)
ClaimsList,
// db::Players::get returns AsPlayer<'q>
PlayerList, //db::Players(conn)::list()
PlayerAdd(NewPlayer), //db::Players(conn)::add(player)
PlayerFetch(i32), // db::Players(conn)::get(id)
PlayerClaims(i32), // db::Players(conn)::get(id).claims()
PlayerNotifications(i32), // db::Players(conn)::get(id).notifications()
PlayerLoot(i32),// db::Players(conn)::get(id).loot()
PlayerUpdateWealth(i32, f64), // db::Players(conn)::get(id).update_wealth(f64)
SellItems(i32, BuySellParams), // db::Players(conn)::get(id).sell(params)
ClaimItems(i32, IdList), // db::Players(conn)::get(id).claim(items)
UndoLastAction(i32), // db::Players(conn)::get(id).undo_last()
AddLoot(NewGroupLoot), // db::Group(conn)::add_loot(loot)
ResolveClaims, // db::Group(conn)::resolve_claims()
}
static ERROR_MSG : &str = "Une erreur est survenue";
pub fn execute(
conn: &DbConnection,
query: ApiActions,
query: ApiEndpoint,
) -> Result<ApiResponse, diesel::result::Error> {
let mut response = ApiResponse::default();
// Return an Option<String> that describes what happened.
// If there is some value, store the actions in db so that it can be reversed.
let action_text: Option<(i32, &str)> = match query {
ApiActions::CheckItemList(names) => {
let (items, errors) = {
let mut found = Vec::new();
let mut errors = String::new();
let items = db::Inventory(conn).all()?;
for name in &names {
if let Some(item) = items.iter().filter(|i| &i.name == name).take(1).next() {
found.push(item.clone())
} else {
errors.push_str(&format!("{},\n", name));
// Inventory
ApiEndpoint::InventoryList => {
match db::Inventory(conn).all() {
Ok(items) => response.set_value(Value::ItemList(items)),
Err(_) => response.push_error(ERROR_MSG),
}
}
(found, errors)
};
response.set_value(Value::ItemList(items));
response.push_error(errors);
dbg!(&names, &response);
None
}
ApiActions::FetchPlayers => {
ApiEndpoint::InventoryCheck(names) => {
match db::Inventory(conn).check_list(names) {
Ok((items, errors)) => {
response.set_value(Value::ItemList(items));
response.push_error(errors);
}
Err(_) => response.push_error(ERROR_MSG),
}
None
}
ApiEndpoint::InventoryAdd(name, value) => {
response.push_error("Not implemented");
None
}
//Shop
ApiEndpoint::ShopList => {
match db::Shop(conn).all() {
Ok(items) => response.set_value(Value::ItemList(items)),
Err(_) => response.push_error(ERROR_MSG),
}
None
}
ApiEndpoint::BuyItems(buyer, params) => {
match db::Shop(conn).buy(params.items, buyer) {
Ok(updates) => {
response.notify("Objets achetés !");
response.push_updates(updates);
Some((buyer, "Achat d'objets"))
},
Err(_) => {
response.push_error(ERROR_MSG);
None
}
}
}
// Players
ApiEndpoint::PlayerList => {
response.set_value(Value::PlayerList(db::Players(conn).all_except_group()?));
None
}
ApiActions::FetchInventory => {
response.set_value(Value::ItemList(db::Inventory(conn).all()?));
None
}
ApiActions::FetchShopInventory => {
response.set_value(Value::ItemList(db::Shop(conn).all()?));
None
}
ApiActions::FetchClaims => {
response.set_value(Value::ClaimList(db::Claims(conn).all()?));
None
}
ApiActions::FetchPlayer(id) => {
ApiEndpoint::PlayerFetch(id) => {
response.set_value(Value::Player(db::Players(conn).find(id)?));
None
}
ApiActions::FetchPlayerClaims(id) => {
ApiEndpoint::ClaimsList => {
response.set_value(Value::ClaimList(db::Claims(conn).all()?));
None
}
ApiEndpoint::PlayerClaims(id) => {
response.set_value(Value::ClaimList(db::Claims(conn).by_player(id)?));
None
}
ApiActions::FetchNotifications(id) => {
ApiEndpoint::PlayerNotifications(id) => {
response.set_value(Value::Notifications(
db::AsPlayer(conn, id).notifications()?,
));
None
}
ApiActions::FetchLoot(id) => {
ApiEndpoint::PlayerLoot(id) => {
response.set_value(Value::ItemList(db::LootManager(conn, id).all()?));
None
}
ApiActions::UpdateWealth(id, amount) => {
response.push_update(db::AsPlayer(conn, id).update_wealth(amount)?);
ApiEndpoint::PlayerUpdateWealth(id, amount) => {
response.push_updates(db::AsPlayer(conn, id).update_wealth(amount)?);
response.notify(format!("Mis à jour ({}po)!", amount));
Some((id, "Argent mis à jour"))
}
ApiActions::BuyItems(id, params) => {
// TODO: check that player has enough money !
let has_enough_gold = true;
if has_enough_gold {
let mut gains: Vec<db::Wealth> = Vec::with_capacity(params.items.len());
for (item_id, price_mod) in params.items.into_iter() {
if let Ok((item, diff)) = db::buy_item_from_shop(conn, id, item_id, price_mod) {
response.push_update(item);
gains.push(diff);
} else {
response.push_error(format!("Error adding {}", item_id));
}
}
let added_items = gains.len();
let total_amount = gains
.into_iter()
.fold(db::Wealth::from_gp(0.0), |acc, i| acc + i);
response.notify(format!(
"{} objets achetés pour {}po",
added_items,
total_amount.to_gp()
));
response.push_update(Update::Wealth(total_amount));
Some((id, "Achat d'objets"))
} else {
response.push_error("Vous n'avez pas assez d'argent !");
None
}
}
// Behavior differs if player is group or regular.
// Group sells item like players then split the total amount among players.
ApiActions::SellItems(id, params) => {
ApiEndpoint::SellItems(id, params) => {
conn.transaction(|| -> Result<Option<(i32, &str)>, diesel::result::Error> {
let mut gains: Vec<db::Wealth> = Vec::with_capacity(params.items.len());
for (loot_id, price_mod) in params.items.iter() {
if let Ok((deleted, diff)) =
db::sell_item_transaction(conn, id, *loot_id, *price_mod)
{
response.push_update(deleted);
gains.push(diff);
} else {
response
.push_error(format!("Erreur lors de la vente (loot_id : {})", loot_id));
}
}
let sold_items = gains.len();
let total_amount = gains
.into_iter()
.fold(db::Wealth::from_gp(0.0), |acc, i| acc + i);
let mut updates = db::LootManager(conn, id).sell(params.items)?;
let total_amount: i32 = updates.iter()
.filter_map(|u| match u {
Update::Wealth(diff) => Some(diff.to_gp() as i32),
_ => None
}).sum();
match id {
0 => {
let players = params.players.unwrap_or_default();
if let Update::Wealth(shared) =
db::split_and_share(conn, total_amount.to_gp() as i32, players)?
{
response.notify(format!(
"Les objets ont été vendus, les joueurs ont reçu (au total) {} po",
shared.to_gp()
));
response.push_update(Update::Wealth(total_amount - shared));
};
updates.append(
&mut db::split_and_share(conn, total_amount, players)?
);
response.notify("Les objets ont été vendus");
response.push_updates(updates);
}
_ => {
response.notify(format!(
"{} objet(s) vendu(s) pour {} po",
sold_items,
total_amount.to_gp()
));
response.push_update(Update::Wealth(total_amount));
response.notify("Objets vendus !");
response.push_updates(updates);
}
}
Ok(Some((id, "Vente d'objets")))
})?
}
ApiActions::ClaimItem(id, item) => {
response.push_update(db::Claims(conn).add(id, item)?);
response.notify("Pour moi !".to_string());
None
}
ApiActions::UnclaimItem(id, item) => {
response.push_update(db::Claims(conn).remove(id, item)?);
response.notify("Bof! Finalement non.".to_string());
None
}
ApiActions::ClaimItems(id, items) => {
ApiEndpoint::ClaimItems(id, items) => {
conn.transaction(|| -> Result<Option<(i32, &str)>, diesel::result::Error> {
let current_claims: HashSet<i32> = db::Claims(conn)
.all()?
@@ -256,21 +223,19 @@ pub fn execute(
let new_claims: HashSet<i32> = items.into_iter().collect();
// Claims to delete
for item in current_claims.difference(&new_claims) {
response.push_update(db::Claims(conn).remove(id, *item)?);
response.push_updates(db::Claims(conn).remove(id, *item)?);
}
// Claims to add
for item in new_claims.difference(&current_claims) {
response.push_update(db::Claims(conn).add(id, *item)?);
response.push_updates(db::Claims(conn).add(id, *item)?);
}
Ok(None)
})?
}
ApiActions::UndoLastAction(id) => {
ApiEndpoint::UndoLastAction(id) => {
if let Ok(event) = db::models::history::get_last_of_player(conn, id) {
let name = String::from(event.name());
for undone in event.undo(conn)?.into_inner().into_iter() {
response.push_update(undone);
}
event.undo(conn)?;
response.notify(format!("'{}' annulé(e)", name));
} else {
response.push_error("Aucune action trouvée")
@@ -278,11 +243,11 @@ pub fn execute(
None
}
// Group actions
ApiActions::AddLoot(data) => {
ApiEndpoint::AddLoot(data) => {
let mut added_items = 0;
for item in data.items.into_iter() {
if let Ok(added) = db::LootManager(conn, 0).add_from(&item) {
response.push_update(added);
response.push_updates(added);
added_items += 1;
} else {
response.push_error(format!("Error adding {:?}", item));
@@ -297,9 +262,19 @@ pub fn execute(
};
Some((0, "Nouveau loot"))
}
ApiEndpoint::ResolveClaims => {
response.push_error("Not implemented!");
None
}
// Admin actions
ApiActions::RefreshShopInventory(items) => {
ApiEndpoint::RefreshShop(items) => {
db::Shop(conn).replace_list(items)?;
response.notify("Inventaire du marchand renouvelé !");
None
}
ApiEndpoint::PlayerAdd(data) => {
db::Players(conn).add(&data.name, data.wealth)?;
response.notify("Joueur ajouté !");
None
}
};

95
src/server.rs
View File

@@ -11,9 +11,8 @@ use futures::{
future::{ok, Either, FutureResult},
Future,
};
use std::env;
use serde_json;
use std::env;
use crate::api;
use lootalot_db as db;
@@ -31,7 +30,7 @@ type MaybeForbidden =
/// Wraps call to the database query and convert its result as a async HttpResponse
fn db_call(
pool: AppPool,
query: api::ApiActions,
query: api::ApiEndpoint,
) -> impl Future<Item = HttpResponse, Error = Error> {
let conn = pool.get().unwrap();
web::block(move || api::execute(&conn, query)).then(|res| match res {
@@ -43,7 +42,7 @@ fn db_call(
})
}
fn restricted_to_group(id: i32, params: (AppPool, api::ApiActions)) -> MaybeForbidden {
fn restricted_to_group(id: i32, params: (AppPool, api::ApiEndpoint)) -> MaybeForbidden {
if id != 0 {
actix_web::Either::B(HttpResponse::Forbidden().finish())
} else {
@@ -102,7 +101,7 @@ where
}
fn configure_api(config: &mut web::ServiceConfig) {
use api::ApiActions as Q;
use api::ApiEndpoint as Q;
config.service(
web::scope("/api")
.wrap(RestrictedAccess)
@@ -110,41 +109,36 @@ fn configure_api(config: &mut web::ServiceConfig) {
web::scope("/players")
.service(
web::resource("/")
.route(web::get().to_async(|pool| db_call(pool, Q::FetchPlayers))), //.route(web::post().to_async(endpoints::new_player))
.route(web::get().to_async(|pool| db_call(pool, Q::PlayerList)))
.route(web::post().to_async(
|pool, player: web::Json<api::NewPlayer>| {
db_call(pool, Q::PlayerAdd(player.into_inner()))
},
)),
) // List of players
.service(
web::scope("/{player_id}")
.route(
/*.route(
"/",
web::get().to_async(|pool, player: PlayerId| {
db_call(pool, Q::FetchPlayer(*player))
}),
)
)*/
.route(
"/notifications",
web::get().to_async(|pool, player: PlayerId| {
db_call(pool, Q::FetchNotifications(*player))
db_call(pool, Q::PlayerNotifications(*player))
}),
)
.service(
web::resource("/claims")
.route(web::get().to_async(|pool, player: PlayerId| {
db_call(pool, Q::FetchPlayerClaims(*player))
db_call(pool, Q::PlayerClaims(*player))
}))
.route(web::post().to_async(
|pool, (player, data): (PlayerId, IdList)| {
db_call(pool, Q::ClaimItems(*player, data.into_inner()))
},
))
.route(web::put().to_async(
|pool, (player, data): (PlayerId, ItemId)| {
db_call(pool, Q::ClaimItem(*player, *data))
},
))
.route(web::delete().to_async(
|pool, (player, data): (PlayerId, ItemId)| {
db_call(pool, Q::UnclaimItem(*player, *data))
},
)),
)
.service(
@@ -152,14 +146,14 @@ fn configure_api(config: &mut web::ServiceConfig) {
//.route(web::get().to_async(...))
.route(web::put().to_async(
|pool, (player, data): (PlayerId, web::Json<f64>)| {
db_call(pool, Q::UpdateWealth(*player, *data))
db_call(pool, Q::PlayerUpdateWealth(*player, *data))
},
)),
)
.service(
web::resource("/loot")
.route(web::get().to_async(|pool, player: PlayerId| {
db_call(pool, Q::FetchLoot(*player))
db_call(pool, Q::PlayerLoot(*player))
}))
.route(web::put().to_async(
move |pool, (player, data): (PlayerId, BuySellParams)| {
@@ -190,25 +184,25 @@ fn configure_api(config: &mut web::ServiceConfig) {
)
.route(
"/claims",
web::get().to_async(|pool| db_call(pool, Q::FetchClaims)),
web::get().to_async(|pool| db_call(pool, Q::ClaimsList)),
)
.service(
web::resource("/shop")
.route(web::get().to_async(|pool| db_call(pool, Q::FetchShopInventory)))
.route(web::get().to_async(|pool| db_call(pool, Q::ShopList)))
.route(
web::post().to_async(|pool, items: web::Json<api::ItemList>| {
db_call(pool, Q::RefreshShopInventory(items.into_inner()))
db_call(pool, Q::RefreshShop(items.into_inner()))
}),
),
)
.service(
web::resource("/items")
.route(
web::get().to_async(move |pool: AppPool| db_call(pool, Q::FetchInventory)),
web::get().to_async(move |pool: AppPool| db_call(pool, Q::InventoryList)),
)
.route(web::post().to_async(
move |pool: AppPool, items: web::Json<Vec<String>>| {
db_call(pool, Q::CheckItemList(items.into_inner()))
db_call(pool, Q::InventoryCheck(items.into_inner()))
},
)),
),
@@ -220,10 +214,10 @@ struct AuthRequest {
key: String,
}
#[derive(Debug,Copy,Clone, Serialize, Deserialize)]
#[derive(Debug, Copy, Clone, Serialize, Deserialize)]
enum SessionKind {
Player(i32),
Admin
Admin,
}
use std::collections::HashMap;
@@ -233,16 +227,18 @@ fn check_key(key: &str, db: HashMap<&str, SessionKind>) -> Option<SessionKind> {
}
fn login(id: Identity, key: web::Query<AuthRequest>) -> HttpResponse {
if let Some(session_kind) =
check_key(
if let Some(session_kind) = check_key(
&key.key.to_string(),
[("0", SessionKind::Player(0)),
[
("0", SessionKind::Player(0)),
("1", SessionKind::Player(1)),
("2", SessionKind::Player(2)),
("admin", SessionKind::Admin),
].iter().cloned().collect::<HashMap<&str, SessionKind>>()
)
{
]
.iter()
.cloned()
.collect::<HashMap<&str, SessionKind>>(),
) {
id.remember(serde_json::to_string(&session_kind).expect("Serialize SessionKind error"));
HttpResponse::build(StatusCode::TEMPORARY_REDIRECT)
.header(header::LOCATION, "/")
@@ -250,7 +246,6 @@ fn login(id: Identity, key: web::Query<AuthRequest>) -> HttpResponse {
} else {
HttpResponse::Forbidden().finish()
}
}
fn logout(id: Identity) -> HttpResponse {
@@ -278,28 +273,30 @@ fn enter_session(id: Identity, pool: AppPool) -> impl Future<Item = HttpResponse
// unlogged case with web::block below
.unwrap_or(SessionKind::Player(-1));
web::block(move || api::execute(&conn, match logged {
SessionKind::Player(id) => api::ApiActions::FetchPlayer(id),
SessionKind::Admin => api::ApiActions::FetchPlayers
}
)).then(
|res| match res {
web::block(move || {
api::execute(
&conn,
match logged {
SessionKind::Player(id) => api::ApiEndpoint::PlayerFetch(id),
SessionKind::Admin => api::ApiEndpoint::PlayerList,
},
)
})
.then(|res| match res {
Ok(r) => HttpResponse::Ok().json(r.value),
Err(e) => {
dbg!(&e);
HttpResponse::Forbidden().finish()
}
},
)
})
}
pub fn serve() -> std::io::Result<()> {
let www_root: String = env::var("WWW_ROOT").expect("WWW_ROOT must be set");
let domain: String = env::var("DOMAIN").expect("DOMAIN must be set");
let pool = db::create_pool();
dbg!(&www_root);
println!("Serving Loot-a-lot on {}", domain);
let key = [0; 32]; // TODO: Use a real key
let domain = "http://localhost:8088";
HttpServer::new(move || {
App::new()
@@ -307,7 +304,7 @@ pub fn serve() -> std::io::Result<()> {
.configure(configure_api)
.wrap(
Cors::new()
.allowed_origin(domain)
.allowed_origin(&domain)
.allowed_methods(vec!["GET", "POST", "PUT", "DELETE", "OPTIONS"])
.max_age(3600),
)
@@ -321,7 +318,7 @@ pub fn serve() -> std::io::Result<()> {
.route("/session", web::get().to_async(enter_session))
.route("/login", web::get().to(login))
.route("/logout", web::get().to(logout))
.service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
//.service(fs::Files::new("/", www_root.clone()).index_file("index.html"))
})
.bind("127.0.0.1:8088")?
.run()