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

learning how to test

Browse Source
This commit is contained in:
Arthur Gerbaud
2019-07-12 15:56:16 +02:00
parent caa8d3fad6
commit 5d54d40bec
13 changed files with 2956 additions and 130 deletions
Download Patch File Download Diff File Expand all files Collapse all files

113
lootalot_db/src/lib.rs
View File

@@ -5,10 +5,10 @@ extern crate diesel;
extern crate serde_derive;
use diesel::prelude::*;
use diesel::r2d2::{self, ConnectionManager};
use diesel::query_dsl::RunQueryDsl;
use diesel::r2d2::{self, ConnectionManager};
mod models;
pub mod models;
mod schema;
/// The connection used
@@ -49,7 +49,7 @@ impl ActionStatus<()> {
/// It offers a convenient way to deal with connection
///
/// # Todo list
/// ```
/// ```text
/// struct DbApi<'q>(&'q DbConnection);
/// ::new() -> DbApi<'q> (Db finds a connection by itself, usefull for cli)
/// ::with_conn(conn) -> DbApi<'q> (uses a user-defined connection)
@@ -77,7 +77,9 @@ impl<'q> DbApi<'q> {
///
/// # Usage
/// ```
/// let conn = DbConnection::establish();
/// use lootalot_db::{DbConnection, DbApi};
/// # use diesel::connection::Connection;
/// let conn = DbConnection::establish(":memory:").unwrap();
/// let api = DbApi::with_conn(&conn);
/// ```
pub fn with_conn(conn: &'q DbConnection) -> Self {
@@ -87,26 +89,17 @@ impl<'q> DbApi<'q> {
///
/// This method consumes the DbApi object.
pub fn fetch_players(self) -> QueryResult<Vec<models::Player>> {
Ok(
schema::players::table
.load::<models::Player>(self.0)?
)
Ok(schema::players::table.load::<models::Player>(self.0)?)
}
/// Fetch the inventory of items
///
/// Consumes the DbApi instance
pub fn fetch_inventory(self) -> QueryResult<Vec<models::Item>> {
Ok(
schema::items::table
.load::<models::Item>(self.0)?
)
Ok(schema::items::table.load::<models::Item>(self.0)?)
}
pub fn fetch_claims(self) -> QueryResult<Vec<models::Claim>> {
Ok(
schema::claims::table
.load::<models::Claim>(self.0)?
)
Ok(schema::claims::table.load::<models::Claim>(self.0)?)
}
/// Wrapper for acting as a specific player
///
@@ -114,6 +107,10 @@ impl<'q> DbApi<'q> {
///
/// # Usage
/// ```
/// # use lootalot_db::{DbConnection, DbApi};
/// # use diesel::connection::Connection;
/// # let conn = DbConnection::establish(":memory:").unwrap();
/// # let api = DbApi::with_conn(&conn);
/// let player_id: i32 = 1; // Id that references player in DB
/// let player = api.as_player(player_id);
/// ```
@@ -136,36 +133,37 @@ pub struct AsPlayer<'q> {
impl<'q> AsPlayer<'q> {
/// Fetch the content of a player's chest
///
/// # Usage
/// ```
/// # extern crate diesel_migrations;
/// # use lootalot_db::{DbConnection, DbApi};
/// # use diesel::connection::Connection;
/// # let conn = DbConnection::establish(":memory:").unwrap();
/// # diesel_migrations::run_pending_migrations(&conn).unwrap();
/// # let api = DbApi::with_conn(&conn);
/// // Get loot of player with id of 1
/// let loot = api.as_player(1).loot().unwrap();
/// assert_eq!(format!("{:?}", loot), "[]".to_string());
/// ```
pub fn loot(self) -> QueryResult<Vec<models::Item>> {
Ok(
models::Item::owned_by(self.id)
.load(self.conn)?
)
Ok(models::Item::owned_by(self.id).load(self.conn)?)
}
/// Adds the value in gold to the player's wealth.
///
/// Value can be negative to substract wealth.
pub fn update_wealth(self, value_in_gp: f32)
-> ActionResult<Option<(i32, i32, i32, i32)>> {
pub fn update_wealth(self, value_in_gp: f32) -> ActionResult<Option<(i32, i32, i32, i32)>> {
use schema::players::dsl::*;
let current_wealth = players
.find(self.id)
.select((cp, sp, gp, pp))
.first::<models::WealthUpdate>(self.conn)?;
.find(self.id)
.select((cp, sp, gp, pp))
.first::<models::WealthUpdate>(self.conn)?;
// TODO: improve this
// should be move inside a WealthUpdate method
let update = models::WealthUpdate::from_gp(
current_wealth.to_gp() + value_in_gp
);
let update = models::WealthUpdate::from_gp(current_wealth.to_gp() + value_in_gp);
// Difference in coins that is sent back
let (old, new) =
(current_wealth.as_tuple(), update.as_tuple());
let diff = (
new.0 - old.0,
new.1 - old.1,
new.2 - old.2,
new.3 - old.3
);
let (old, new) = (current_wealth.as_tuple(), update.as_tuple());
let diff = (new.0 - old.0, new.1 - old.1, new.2 - old.2, new.3 - old.3);
diesel::update(players)
.filter(id.eq(self.id))
.set(&update)
@@ -175,26 +173,31 @@ impl<'q> AsPlayer<'q> {
1 => ActionStatus {
executed: true,
response: Some(diff),
},
},
_ => ActionStatus {
executed: false,
response: None,
}, })
},
})
}
/// Put a claim on a specific item
pub fn claim(self, item: i32) -> ActionResult<()> {
// TODO: check that looted item exists
let exists: bool =
diesel::select(models::Loot::exists(item))
.get_result(self.conn)?;
let exists: bool = diesel::select(models::Loot::exists(item)).get_result(self.conn)?;
if !exists {
return Ok(ActionStatus::nop())
return Ok(ActionStatus::nop());
};
let request = models::NewClaim {
player_id: self.id,
loot_id: item,
};
let request = models::NewClaim { player_id: self.id, loot_id: item };
diesel::insert_into(schema::claims::table)
.values(&request)
.execute(self.conn)
.map(|r| match r { 1 => ActionStatus::ok(), _ => ActionStatus::nop() })
.map(|r| match r {
1 => ActionStatus::ok(),
_ => ActionStatus::nop(),
})
}
/// Withdraw claim
pub fn unclaim(self, item: i32) -> ActionResult<()> {
@@ -202,9 +205,13 @@ impl<'q> AsPlayer<'q> {
diesel::delete(
claims
.filter(loot_id.eq(item))
.filter(player_id.eq(self.id)))
.execute(self.conn)
.map(|r| match r { 1 => ActionStatus::ok(), _ => ActionStatus::nop() })
.filter(player_id.eq(self.id)),
)
.execute(self.conn)
.map(|r| match r {
1 => ActionStatus::ok(),
_ => ActionStatus::nop(),
})
}
}
@@ -212,12 +219,14 @@ impl<'q> AsPlayer<'q> {
pub struct AsAdmin<'q>(&'q DbConnection);
impl<'q> AsAdmin<'q> {
pub fn add_player(self, name: String, start_wealth: f32) -> ActionResult<()> {
diesel::insert_into(schema::players::table)
.values(&models::NewPlayer::create(&name, start_wealth))
.execute(self.0)
.map(|r| match r { 1 => ActionStatus::ok(), _ => ActionStatus::nop() })
.map(|r| match r {
1 => ActionStatus::ok(),
_ => ActionStatus::nop(),
})
}
pub fn resolve_claims(self) -> ActionResult<()> {
@@ -239,7 +248,7 @@ impl<'q> AsAdmin<'q> {
/// Uses the DATABASE_URL environment variable (must be set)
pub fn create_pool() -> Pool {
let connspec = std::env::var("DATABASE_URL").expect("DATABASE_URL");
dbg!( &connspec );
dbg!(&connspec);
let manager = ConnectionManager::<DbConnection>::new(connspec);
r2d2::Pool::builder()
.build(manager)
@@ -247,6 +256,4 @@ pub fn create_pool() -> Pool {
}
#[cfg(test)]
mod tests {
}
mod tests {}

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

@@ -1,6 +1,6 @@
use diesel::prelude::*;
use crate::schema::claims;
use crate::models::item::Loot;
use crate::schema::claims;
use diesel::prelude::*;
#[derive(Identifiable, Queryable, Associations, Serialize, Debug)]
#[belongs_to(Loot)]
@@ -12,7 +12,7 @@ pub struct Claim {
}
#[derive(Insertable, Debug)]
#[table_name="claims"]
#[table_name = "claims"]
pub struct NewClaim {
pub player_id: i32,
pub loot_id: i32,

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

@@ -1,13 +1,11 @@
use diesel::prelude::*;
use diesel::dsl::{Eq, Filter, Select, exists, Find };
use diesel::expression::exists::Exists;
use crate::schema::{looted, items};
use crate::schema::{items, looted};
use crate::DbConnection;
use diesel::dsl::{exists, Eq, Filter, Find, Select};
use diesel::expression::exists::Exists;
use diesel::prelude::*;
type ItemColumns =
( looted::id, looted::name, looted::base_price, );
const ITEM_COLUMNS: ItemColumns =
( looted::id, looted::name, looted::base_price, );
type ItemColumns = (looted::id, looted::name, looted::base_price);
const ITEM_COLUMNS: ItemColumns = (looted::id, looted::name, looted::base_price);
type OwnedBy = Select<OwnedLoot, ItemColumns>;
/// Represents a unique item in inventory
@@ -25,8 +23,7 @@ pub struct Item {
impl Item {
/// Public proxy for Loot::owned_by that selects only Item fields
pub fn owned_by(player: i32) -> OwnedBy {
Loot::owned_by(player)
.select(ITEM_COLUMNS)
Loot::owned_by(player).select(ITEM_COLUMNS)
}
}
@@ -35,7 +32,7 @@ type OwnedLoot = Filter<looted::table, WithOwner>;
/// Represents an item that has been looted
#[derive(Identifiable, Debug, Queryable, Serialize)]
#[table_name="looted"]
#[table_name = "looted"]
pub(crate) struct Loot {
id: i32,
name: String,
@@ -46,8 +43,7 @@ pub(crate) struct Loot {
impl Loot {
/// A filter on Loot that is owned by given player
pub(crate) fn owned_by(id: i32) -> OwnedLoot {
looted::table
.filter(looted::owner_id.eq(id))
looted::table.filter(looted::owner_id.eq(id))
}
pub(crate) fn exists(id: i32) -> Exists<Find<looted::table, i32>> {
@@ -55,7 +51,9 @@ impl Loot {
}
}
/// Description of an item : (name, value in gold)
type ItemDesc<'a> = (&'a str, i32);
/// An item being looted or bought.
///
/// The owner is set to 0 in case of looting,
@@ -69,6 +67,7 @@ struct NewLoot<'a> {
}
impl<'a> NewLoot<'a> {
/// A new loot going to the group (loot procedure)
fn to_group(desc: ItemDesc<'a>) -> Self {
Self {
name: desc.0,
@@ -77,6 +76,7 @@ impl<'a> NewLoot<'a> {
}
}
/// A new loot going to a specific player (buy procedure)
fn to_player(player: i32, desc: ItemDesc<'a>) -> Self {
Self {
name: desc.0,

6
lootalot_db/src/models/mod.rs
View File

@@ -1,8 +1,8 @@
mod claim;
mod item;
mod player;
mod claim;
pub use claim::{Claim, NewClaim};
pub use item::Item;
pub(crate) use item::Loot;
pub use player::{Player, NewPlayer, WealthUpdate};
pub use claim::{NewClaim, Claim};
pub use player::{NewPlayer, Player, WealthUpdate};

37
lootalot_db/src/models/player.rs
View File

@@ -1,6 +1,6 @@
use diesel::prelude::*;
use crate::schema::players;
use crate::DbConnection;
use diesel::prelude::*;
/// Representation of a player in database
#[derive(Debug, Queryable, Serialize)]
@@ -14,7 +14,6 @@ pub struct Player {
pp: i32,
}
/// Unpack a floating value in gold pieces to integer
/// values of copper, silver, gold and platinum pieces
///
@@ -38,33 +37,39 @@ fn unpack_gold_value(gold: f32) -> (i32, i32, i32, i32) {
/// The values held here are the amount of pieces to add or
/// substract to player wealth.
#[derive(Queryable, AsChangeset, Debug)]
#[table_name="players"]
#[table_name = "players"]
pub struct WealthUpdate {
cp: i32,
sp: i32,
gp: i32,
pp: i32
pp: i32,
}
impl WealthUpdate{
impl WealthUpdate {
/// Unpack individual pieces counts from gold value
pub fn from_gp(gp: f32) -> Self {
let (cp, sp, gp, pp) = unpack_gold_value(gp);
Self { cp, sp, gp, pp }
}
/// Convert total value to a floating value in gold pieces
///
/// # Examples
/// ```
/// # use lootalot_db::models::WealthUpdate;
/// let wealth = WealthUpdate::from_gp(403.21);
/// assert_eq!(wealth.to_gp(), 403.21);
/// ```
pub fn to_gp(&self) -> f32 {
let i = self.pp * 100 + self.gp;
let f = ( self.sp * 10 + self.cp ) as f32 / 100.0;
let f = (self.sp * 10 + self.cp) as f32 / 100.0;
i as f32 + f
}
/// Pack the counts inside a tuple, from lower to higher coin value.
pub fn as_tuple(&self) -> (i32, i32, i32, i32) {
(self.cp, self.sp, self.gp, self.pp)
}
}
/// Representation of a new player record
#[derive(Insertable)]
#[table_name = "players"]
@@ -98,13 +103,13 @@ mod tests {
fn test_unpack_gold_values() {
use super::unpack_gold_value;
let test_values = [
(1.0, (0,0,1,0)),
(1.23, (3,2,1,0)),
(1.03, (3,0,1,0)),
(100.23, (3,2,0,1)),
(-100.23, (-3,-2,-0,-1)),
(10189.23, (3,2,89,101)),
(-8090.20, (0,-2,-90,-80))
(1.0, (0, 0, 1, 0)),
(1.23, (3, 2, 1, 0)),
(1.03, (3, 0, 1, 0)),
(100.23, (3, 2, 0, 1)),
(-100.23, (-3, -2, -0, -1)),
(10189.23, (3, 2, 89, 101)),
(-8090.20, (0, -2, -90, -80)),
];
for (tested, expected) in test_values.into_iter() {

7
lootalot_db/src/schema.rs
View File

@@ -40,9 +40,4 @@ joinable!(claims -> looted (loot_id));
joinable!(claims -> players (player_id));
joinable!(looted -> players (owner_id));
allow_tables_to_appear_in_same_query!(
claims,
items,
looted,
players,
);
allow_tables_to_appear_in_same_query!(claims, items, looted, players,);