89 lines
2.8 KiB
Rust
89 lines
2.8 KiB
Rust
use crate::database::Database;
|
|
use crate::error::{GeoffreyDBError, Result};
|
|
use geoffrey_models::models::locations::market::Market;
|
|
use geoffrey_models::models::locations::town::Town;
|
|
use geoffrey_models::models::locations::{
|
|
Location, LocationData, LocationDataDb, LocationDb, LocationType,
|
|
};
|
|
use geoffrey_models::models::player::Player;
|
|
|
|
pub fn load_location_data(db: &Database, data: &LocationDataDb) -> Result<LocationData> {
|
|
Ok(match data {
|
|
LocationDataDb::Base => LocationData::Base,
|
|
LocationDataDb::Shop(shop_data) => LocationData::Shop(shop_data.clone()),
|
|
LocationDataDb::Attraction => LocationData::Attraction,
|
|
LocationDataDb::Town(town_data) => {
|
|
let town_data = Town {
|
|
residents: db
|
|
.filter(|id, _: &Player| town_data.residents.contains(&id))?
|
|
.collect(),
|
|
};
|
|
|
|
LocationData::Town(town_data)
|
|
}
|
|
LocationDataDb::Farm(farm_data) => LocationData::Farm(farm_data.clone()),
|
|
LocationDataDb::Market(market_data) => {
|
|
let shops: Result<Vec<Location>> = db
|
|
.filter(|id, _: &LocationDb| market_data.shops.contains(&id))?
|
|
.map(|loc| load_location(db, &loc))
|
|
.collect();
|
|
|
|
let market_data = Market {
|
|
is_public: market_data.is_public,
|
|
shops: shops?,
|
|
};
|
|
|
|
LocationData::Market(market_data)
|
|
}
|
|
})
|
|
}
|
|
|
|
pub fn load_location(db: &Database, location: &LocationDb) -> Result<Location> {
|
|
let owners: Vec<Player> = db
|
|
.filter(|id, _: &Player| location.owners().contains(&id))?
|
|
.collect();
|
|
let loc_data = load_location_data(db, &location.loc_data)?;
|
|
|
|
Ok(Location::from_db_location(
|
|
location.clone(),
|
|
owners,
|
|
loc_data,
|
|
))
|
|
}
|
|
|
|
pub fn find_location_by_name(
|
|
db: &Database,
|
|
location_name: &str,
|
|
owner_id: u64,
|
|
) -> Result<LocationDb> {
|
|
let filter = regex::Regex::new(format!(r"(?i)^{}$", location_name).as_str()).unwrap();
|
|
|
|
let location: LocationDb = db
|
|
.filter(|_, loc: &LocationDb| {
|
|
loc.owners().contains(&owner_id) && filter.is_match(loc.name.as_str())
|
|
})?
|
|
.next()
|
|
.ok_or(GeoffreyDBError::NotFound)?;
|
|
|
|
Ok(location)
|
|
}
|
|
|
|
pub fn find_location_by_name_type(
|
|
db: &Database,
|
|
location_name: &str,
|
|
owner_id: u64,
|
|
loc_type: LocationType,
|
|
) -> Result<LocationDb> {
|
|
let filter = regex::Regex::new(format!(r"(?i)^{}$", location_name).as_str()).unwrap();
|
|
|
|
let location: LocationDb = db
|
|
.filter(|_, loc: &LocationDb| {
|
|
let lt: LocationType = LocationType::from(&loc.loc_data);
|
|
loc.owners().contains(&owner_id) && filter.is_match(loc.name.as_str()) && lt == loc_type
|
|
})?
|
|
.next()
|
|
.ok_or(GeoffreyDBError::NotFound)?;
|
|
|
|
Ok(location)
|
|
}
|