306 lines
11 KiB
Rust
306 lines
11 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::json;
|
|
|
|
use crate::{get_pg, transaction::Transaction};
|
|
|
|
pub fn timestamp_range(year: i32, month: u32) -> (i64, i64) {
|
|
let d = chrono::NaiveDate::from_ymd_opt(year, month, 0).unwrap();
|
|
let t = chrono::NaiveTime::from_hms_milli_opt(0, 0, 0, 0).unwrap();
|
|
let start = chrono::NaiveDateTime::new(d, t).and_utc().timestamp();
|
|
|
|
assert!(month <= 12);
|
|
|
|
let end = if month == 12 {
|
|
let d = chrono::NaiveDate::from_ymd_opt(year + 1, month, 0).unwrap();
|
|
let t = chrono::NaiveTime::from_hms_milli_opt(0, 0, 0, 0).unwrap();
|
|
chrono::NaiveDateTime::new(d, t).and_utc().timestamp()
|
|
} else {
|
|
let d = chrono::NaiveDate::from_ymd_opt(year, month + 1, 0).unwrap();
|
|
let t = chrono::NaiveTime::from_hms_milli_opt(0, 0, 0, 0).unwrap();
|
|
chrono::NaiveDateTime::new(d, t).and_utc().timestamp()
|
|
};
|
|
|
|
(start, end)
|
|
}
|
|
|
|
/// Represents a specific instance of an item with potential variations.
|
|
///
|
|
/// This struct is used to describe a particular variation or instance of an item
|
|
/// in the real world. It may include attributes or properties that deviate from
|
|
/// the standard definition of the item. For example, different colors, sizes, or
|
|
/// configurations.
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
|
|
pub struct Variant {
|
|
/// Associated Item
|
|
pub item: String,
|
|
/// Variant ID
|
|
pub variant: String,
|
|
/// Variant Name
|
|
pub name: String,
|
|
/// Minimum amount
|
|
pub min: Option<i64>,
|
|
/// Days until expiry
|
|
pub expiry: Option<i64>,
|
|
/// Associated barcodes
|
|
pub barcodes: Option<Vec<i64>>
|
|
}
|
|
|
|
impl Variant {
|
|
/// Create variant from itemdb yaml
|
|
pub fn from_yml(json: &serde_yaml::Value, variant: &str, item: &str) -> Self {
|
|
Self {
|
|
item: item.to_string(),
|
|
variant: variant.to_string(),
|
|
name: json
|
|
.as_mapping()
|
|
.unwrap()
|
|
.get("name")
|
|
.unwrap()
|
|
.as_str()
|
|
.unwrap()
|
|
.to_string(),
|
|
min: json
|
|
.as_mapping()
|
|
.unwrap()
|
|
.get("min")
|
|
.map(|x| x.as_i64().unwrap()),
|
|
expiry: json
|
|
.as_mapping()
|
|
.unwrap()
|
|
.get("expiry")
|
|
.map(|x| x.as_i64().unwrap()),
|
|
barcodes: json.as_mapping().unwrap().get("barcodes").map(|x| {
|
|
x.as_sequence().unwrap().into_iter().map(|x| x.as_i64().unwrap()).collect()
|
|
})
|
|
}
|
|
}
|
|
|
|
pub fn item_variant_id(&self) -> String {
|
|
format!("{}::{}", self.item, self.variant)
|
|
}
|
|
|
|
/// Returns the IDs of Transactions from this Item Variant.
|
|
pub async fn supply_log(&self) -> Vec<String> {
|
|
let res: Vec<(uuid::Uuid,)> = sqlx::query_as(
|
|
"SELECT id FROM transactions WHERE item = $1 AND variant = $2 ORDER BY created DESC",
|
|
)
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.fetch_all(get_pg!())
|
|
.await
|
|
.unwrap();
|
|
|
|
res.into_iter().map(|x| x.0.to_string()).collect()
|
|
}
|
|
|
|
/// Returns the active Transaction of this Item Variant which are not yet consumed.
|
|
pub async fn inventory(&self) -> Vec<Transaction> {
|
|
sqlx::query_as("SELECT * FROM transactions WHERE item = $1 AND variant = $2 AND consumed_timestamp IS NULL ORDER BY created DESC")
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.fetch_all(get_pg!()).await.unwrap()
|
|
}
|
|
|
|
/// Returns the IDs of the Transactions from this Item Variant which are consumed.
|
|
pub async fn demand_log(&self, destination: Option<&str>) -> Vec<String> {
|
|
let res: Vec<(uuid::Uuid,)> = if let Some(destination) = destination {
|
|
sqlx::query_as(
|
|
"SELECT id FROM transactions WHERE item = $1 AND variant = $2 AND consumed_timestamp IS NOT NULL AND destination = $3 ORDER BY created DESC"
|
|
)
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.bind(destination)
|
|
.fetch_all(get_pg!()).await.unwrap()
|
|
} else {
|
|
sqlx::query_as(
|
|
"SELECT id FROM transactions WHERE item = $1 AND variant = $2 AND consumed_timestamp IS NOT NULL ORDER BY created DESC"
|
|
)
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.fetch_all(get_pg!()).await.unwrap()
|
|
};
|
|
res.into_iter().map(|x| x.0.to_string()).collect()
|
|
}
|
|
|
|
pub async fn demand(uuid: &uuid::Uuid, price: f64, destination: &str) -> Option<Transaction> {
|
|
// check if transaction exists
|
|
let t = Transaction::get(uuid).await?;
|
|
Some(t.consume(price, destination).await)
|
|
}
|
|
|
|
/// Records a supply transaction in the database.
|
|
///
|
|
/// # Arguments
|
|
///
|
|
/// * `price` - The price of the supplied items.
|
|
/// * `origin` - The origin or source of the supplied items.
|
|
///
|
|
/// # Returns
|
|
///
|
|
/// Returns a UUID string representing the transaction.
|
|
pub async fn supply(
|
|
&self,
|
|
price: f64,
|
|
origin: Option<&str>,
|
|
location: Option<&str>,
|
|
note: Option<&str>,
|
|
) -> Transaction {
|
|
Transaction::new(&self.item, &self.variant, price, origin, location, note).await
|
|
}
|
|
|
|
/// Returns all Transactions of this Item Variant
|
|
pub async fn get_all_transactions(&self) -> Vec<Transaction> {
|
|
sqlx::query_as(
|
|
"SELECT * FROM transactions WHERE item = $1 AND variant = $2 ORDER BY created DESC",
|
|
)
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.fetch_all(get_pg!())
|
|
.await
|
|
.unwrap()
|
|
}
|
|
|
|
pub async fn get_transaction_timeslice(&self, year: i32, month: u32) -> Vec<Transaction> {
|
|
let (start, end) = timestamp_range(year, month);
|
|
|
|
sqlx::query_as("SELECT * FROM transactions WHERE created BETWEEN to_timestamp($1) AND to_timestamp($2) ORDER BY created DESC")
|
|
.bind(start)
|
|
.bind(end)
|
|
.fetch_all(get_pg!()).await.unwrap()
|
|
}
|
|
|
|
pub async fn get_unique_origins(&self) -> Vec<String> {
|
|
let res: Vec<(String,)> = sqlx::query_as("SELECT DISTINCT(origin) FROM transactions WHERE origin NOT LIKE 'flow::%' AND item = $1 AND variant = $2")
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.fetch_all(get_pg!()).await.unwrap();
|
|
res.into_iter().map(|x| x.0).collect()
|
|
}
|
|
|
|
pub async fn get_unique_destinations(&self) -> Vec<String> {
|
|
let res: Vec<(String,)> = sqlx::query_as("SELECT DISTINCT(destination) FROM transactions WHERE destination NOT LIKE 'flow::%' AND item = $1 AND variant = $2")
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.fetch_all(get_pg!()).await.unwrap();
|
|
res.into_iter().map(|x| x.0).collect()
|
|
}
|
|
|
|
pub async fn price_history_by_origin(&self, origin: &str, limit: Option<i64>) -> Vec<f64> {
|
|
let res: Vec<(f64,)> = sqlx::query_as(
|
|
&format!("SELECT price FROM transactions WHERE item = $1 AND variant = $2 AND origin = $3 ORDER BY created DESC {}", if let Some(limit) = limit {
|
|
format!("LIMIT {limit}")
|
|
} else { String::new() })
|
|
)
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.bind(origin)
|
|
.fetch_all(get_pg!()).await.unwrap();
|
|
res.into_iter().map(|x| x.0).collect()
|
|
}
|
|
|
|
pub async fn get_latest_price(&self, origin: Option<String>) -> f64 {
|
|
if let Some(origin) = origin {
|
|
let res: (f64,) = sqlx::query_as("SELECT price FROM transactions WHERE item = $1 AND variant = $2 AND origin = $3 ORDER BY created DESC LIMIT 1")
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.bind(origin)
|
|
.fetch_one(get_pg!()).await.unwrap();
|
|
res.0
|
|
} else {
|
|
let res: (f64,) = sqlx::query_as("SELECT price FROM transactions WHERE item = $1 AND variant = $2 ORDER BY created DESC LIMIT 1")
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.bind(origin)
|
|
.fetch_one(get_pg!()).await.unwrap();
|
|
res.0
|
|
}
|
|
}
|
|
|
|
/// Check if item variant is below minimum. Returns if this is the case and the number needed to fulfill minimum
|
|
pub async fn is_below_min(&self) -> (bool, i64) {
|
|
if let Some(min) = self.min {
|
|
let amount = self.inventory().await.len() as i64;
|
|
if amount < min {
|
|
return (true, min - amount);
|
|
}
|
|
}
|
|
|
|
(false, 0)
|
|
}
|
|
|
|
pub async fn stat(&self, full: bool) -> serde_json::Value {
|
|
let active_transactions = self.inventory().await;
|
|
|
|
let total_price: f64 = active_transactions.iter().map(|x| x.price).sum();
|
|
|
|
if !full {
|
|
return json!({
|
|
"amount": active_transactions.len(),
|
|
"total_price": total_price
|
|
});
|
|
}
|
|
|
|
let all_transactions: Vec<Transaction> = sqlx::query_as(
|
|
"SELECT * FROM transactions WHERE item = $1 AND variant = $2 ORDER BY created DESC",
|
|
)
|
|
.bind(&self.item)
|
|
.bind(&self.variant)
|
|
.fetch_all(get_pg!())
|
|
.await
|
|
.unwrap();
|
|
|
|
let mut expired_count = 0.0;
|
|
|
|
for t in &all_transactions {
|
|
if t.is_expired().await {
|
|
expired_count += 1.0;
|
|
}
|
|
}
|
|
|
|
let expiry_rate = expired_count / all_transactions.len() as f64;
|
|
let mut origin_stat = HashMap::new();
|
|
|
|
for origin in self.get_unique_origins().await {
|
|
let transactions_from_origin = active_transactions
|
|
.iter()
|
|
.filter(|x| x.origin.as_ref().map(|x| *x == origin).unwrap_or(false))
|
|
.collect::<Vec<_>>();
|
|
|
|
let prices = self
|
|
.price_history_by_origin(&origin, None)
|
|
.await
|
|
.into_iter()
|
|
.map(|x| x)
|
|
.collect::<Vec<_>>();
|
|
let prices_len = prices.len() as f64;
|
|
let prices_summed = prices.into_iter().reduce(|acc, e| acc + e).unwrap_or(0.0);
|
|
|
|
let stat_json = json!({
|
|
"average_price": prices_summed / prices_len,
|
|
"inventory": transactions_from_origin.len()
|
|
});
|
|
|
|
origin_stat.insert(origin, stat_json);
|
|
}
|
|
|
|
json!({
|
|
"amount": active_transactions.len(),
|
|
"total_price": total_price,
|
|
"expiry_rate": expiry_rate,
|
|
"origins": origin_stat
|
|
})
|
|
}
|
|
|
|
pub fn api_json(&self) -> serde_json::Value {
|
|
json!({
|
|
"item": self.item,
|
|
"variant": self.variant,
|
|
"name": self.name,
|
|
"min": self.min,
|
|
"expiry": self.expiry,
|
|
"barcodes": self.barcodes
|
|
})
|
|
}
|
|
}
|