127 lines
3.2 KiB
Rust
127 lines
3.2 KiB
Rust
use crate::store::BaseData;
|
|
use rhai::{CustomType, TypeBuilder};
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
/// Bid status enumeration
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
|
pub enum BidStatus {
|
|
#[default]
|
|
Pending,
|
|
Confirmed,
|
|
Assigned,
|
|
Cancelled,
|
|
Done,
|
|
}
|
|
|
|
/// Billing period enumeration
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default)]
|
|
pub enum BillingPeriod {
|
|
#[default]
|
|
Hourly,
|
|
Monthly,
|
|
Yearly,
|
|
Biannually,
|
|
Triannually,
|
|
}
|
|
|
|
/// I can bid for infra, and optionally get accepted
|
|
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Default, crate::DeriveObject)]
|
|
pub struct Bid {
|
|
pub base_data: BaseData,
|
|
/// links back to customer for this capacity (user on ledger)
|
|
#[index]
|
|
pub customer_id: u32,
|
|
/// nr of slices I need in 1 machine
|
|
pub compute_slices_nr: i32,
|
|
/// price per 1 GB slice I want to accept
|
|
pub compute_slice_price: f64,
|
|
/// nr of storage slices needed
|
|
pub storage_slices_nr: i32,
|
|
/// price per 1 GB storage slice I want to accept
|
|
pub storage_slice_price: f64,
|
|
pub status: BidStatus,
|
|
/// if obligation then will be charged and money needs to be in escrow, otherwise its an intent
|
|
pub obligation: bool,
|
|
/// epoch timestamp
|
|
pub start_date: u32,
|
|
/// epoch timestamp
|
|
pub end_date: u32,
|
|
/// signature as done by a user/consumer to validate their identity and intent
|
|
pub signature_user: String,
|
|
pub billing_period: BillingPeriod,
|
|
}
|
|
|
|
impl Bid {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
base_data: BaseData::new(),
|
|
customer_id: 0,
|
|
compute_slices_nr: 0,
|
|
compute_slice_price: 0.0,
|
|
storage_slices_nr: 0,
|
|
storage_slice_price: 0.0,
|
|
status: BidStatus::default(),
|
|
obligation: false,
|
|
start_date: 0,
|
|
end_date: 0,
|
|
signature_user: String::new(),
|
|
billing_period: BillingPeriod::default(),
|
|
}
|
|
}
|
|
|
|
pub fn customer_id(mut self, v: u32) -> Self {
|
|
self.customer_id = v;
|
|
self
|
|
}
|
|
|
|
pub fn compute_slices_nr(mut self, v: i32) -> Self {
|
|
self.compute_slices_nr = v;
|
|
self
|
|
}
|
|
|
|
pub fn compute_slice_price(mut self, v: f64) -> Self {
|
|
self.compute_slice_price = v;
|
|
self
|
|
}
|
|
|
|
pub fn storage_slices_nr(mut self, v: i32) -> Self {
|
|
self.storage_slices_nr = v;
|
|
self
|
|
}
|
|
|
|
pub fn storage_slice_price(mut self, v: f64) -> Self {
|
|
self.storage_slice_price = v;
|
|
self
|
|
}
|
|
|
|
pub fn status(mut self, v: BidStatus) -> Self {
|
|
self.status = v;
|
|
self
|
|
}
|
|
|
|
pub fn obligation(mut self, v: bool) -> Self {
|
|
self.obligation = v;
|
|
self
|
|
}
|
|
|
|
pub fn start_date(mut self, v: u32) -> Self {
|
|
self.start_date = v;
|
|
self
|
|
}
|
|
|
|
pub fn end_date(mut self, v: u32) -> Self {
|
|
self.end_date = v;
|
|
self
|
|
}
|
|
|
|
pub fn signature_user(mut self, v: impl ToString) -> Self {
|
|
self.signature_user = v.to_string();
|
|
self
|
|
}
|
|
|
|
pub fn billing_period(mut self, v: BillingPeriod) -> Self {
|
|
self.billing_period = v;
|
|
self
|
|
}
|
|
}
|