fugle 0.3.8

A Simple, Lightweight, Fast and Safe Fugle Library
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use time::Date;

use crate::schema::de_date;

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase", default)]
pub struct Candle {
    #[serde(deserialize_with = "de_date")]
    pub date: Date,
    pub open: Decimal,
    pub high: Decimal,
    pub low: Decimal,
    pub close: Decimal,
    pub volume: u64,
    pub turnover: u64,
    pub change: Decimal,
}

impl Default for Candle {
    fn default() -> Candle {
        Candle {
            date: Date::MIN,
            open: Decimal::new(0, 2),
            high: Decimal::new(0, 2),
            low: Decimal::new(0, 2),
            close: Decimal::new(0, 2),
            volume: 0,
            turnover: 0,
            change: Decimal::new(0, 2),
        }
    }
}

#[derive(Debug, Deserialize, Serialize)]
#[serde(rename_all = "camelCase", default)]
pub struct CandlesResponse {
    pub symbol_id: String,
    #[serde(rename = "type")]
    pub typ: String,
    pub exchange: String,
    pub market: String,
    pub candles: Vec<Candle>,
}

impl Default for CandlesResponse {
    fn default() -> CandlesResponse {
        CandlesResponse {
            symbol_id: "".to_string(),
            typ: "".to_string(),
            exchange: "".to_string(),
            market: "".to_string(),
            candles: Vec::with_capacity(0),
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn test_candle_default() {
        let c = Candle::default();
        assert_eq!(c.date, Date::MIN);
        assert_eq!(c.open, Decimal::new(0, 2));
        assert_eq!(c.high, Decimal::new(0, 2));
        assert_eq!(c.low, Decimal::new(0, 2));
        assert_eq!(c.close, Decimal::new(0, 2));
        assert_eq!(c.volume, 0);
        assert_eq!(c.turnover, 0);
        assert_eq!(c.change, Decimal::new(0, 2));
    }
}