boris
132 lines
3.8 KiB
Rust
132 lines
3.8 KiB
Rust
use chrono::NaiveDate;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Instrument {
|
|
pub symbol: String,
|
|
pub name: String,
|
|
pub board: String,
|
|
pub round_lot: u32,
|
|
#[serde(default, with = "optional_date_format")]
|
|
pub listed_at: Option<NaiveDate>,
|
|
#[serde(default, with = "optional_date_format")]
|
|
pub delisted_at: Option<NaiveDate>,
|
|
#[serde(default = "default_status")]
|
|
pub status: String,
|
|
}
|
|
|
|
impl Instrument {
|
|
pub fn effective_round_lot(&self) -> u32 {
|
|
self.round_lot.max(1)
|
|
}
|
|
|
|
pub fn minimum_order_quantity(&self) -> u32 {
|
|
let board = self.board.trim();
|
|
if board.eq_ignore_ascii_case("KSH") {
|
|
200
|
|
} else if board.eq_ignore_ascii_case("BJS")
|
|
|| board.eq_ignore_ascii_case("BJ")
|
|
|| board.eq_ignore_ascii_case("BJSE")
|
|
{
|
|
100
|
|
} else {
|
|
self.effective_round_lot()
|
|
}
|
|
}
|
|
|
|
pub fn order_step_size(&self) -> u32 {
|
|
let board = self.board.trim();
|
|
if board.eq_ignore_ascii_case("KSH")
|
|
|| board.eq_ignore_ascii_case("BJS")
|
|
|| board.eq_ignore_ascii_case("BJ")
|
|
|| board.eq_ignore_ascii_case("BJSE")
|
|
{
|
|
1
|
|
} else {
|
|
self.effective_round_lot()
|
|
}
|
|
}
|
|
|
|
pub fn is_delisted_before(&self, date: NaiveDate) -> bool {
|
|
self.delisted_at
|
|
.is_some_and(|delisted_at| delisted_at < date)
|
|
}
|
|
|
|
pub fn is_delisted_on_or_before(&self, date: NaiveDate) -> bool {
|
|
self.delisted_at
|
|
.is_some_and(|delisted_at| delisted_at <= date)
|
|
}
|
|
|
|
pub fn is_active_on(&self, date: NaiveDate) -> bool {
|
|
self.listed_at.is_none_or(|listed_at| listed_at <= date)
|
|
&& !self.is_delisted_before(date)
|
|
&& !(self.status.eq_ignore_ascii_case("inactive") && self.delisted_at.is_none())
|
|
}
|
|
}
|
|
|
|
fn default_status() -> String {
|
|
"active".to_string()
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::Instrument;
|
|
|
|
fn instrument(board: &str, round_lot: u32) -> Instrument {
|
|
Instrument {
|
|
symbol: "000001.SZ".to_string(),
|
|
name: "test".to_string(),
|
|
board: board.to_string(),
|
|
round_lot,
|
|
listed_at: None,
|
|
delisted_at: None,
|
|
status: "active".to_string(),
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn order_quantity_rules_are_case_insensitive_without_allocating_normalized_boards() {
|
|
let kcb = instrument(" kSh ", 100);
|
|
assert_eq!(kcb.minimum_order_quantity(), 200);
|
|
assert_eq!(kcb.order_step_size(), 1);
|
|
|
|
let bjse = instrument("bjse", 100);
|
|
assert_eq!(bjse.minimum_order_quantity(), 100);
|
|
assert_eq!(bjse.order_step_size(), 1);
|
|
|
|
let main_board = instrument("SZSE", 50);
|
|
assert_eq!(main_board.minimum_order_quantity(), 50);
|
|
assert_eq!(main_board.order_step_size(), 50);
|
|
}
|
|
}
|
|
|
|
mod optional_date_format {
|
|
use chrono::NaiveDate;
|
|
use serde::{self, Deserialize, Deserializer, Serializer};
|
|
|
|
const FORMAT: &str = "%Y-%m-%d";
|
|
|
|
pub fn serialize<S>(value: &Option<NaiveDate>, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
match value {
|
|
Some(date) => serializer.serialize_some(&date.format(FORMAT).to_string()),
|
|
None => serializer.serialize_none(),
|
|
}
|
|
}
|
|
|
|
pub fn deserialize<'de, D>(deserializer: D) -> Result<Option<NaiveDate>, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
let value = Option::<String>::deserialize(deserializer)?;
|
|
match value.as_deref().map(str::trim).filter(|v| !v.is_empty()) {
|
|
Some(text) => NaiveDate::parse_from_str(text, FORMAT)
|
|
.map(Some)
|
|
.map_err(serde::de::Error::custom),
|
|
None => Ok(None),
|
|
}
|
|
}
|
|
}
|