zero4rs 2.0.0

zero4rs is a powerful, pragmatic, and extremely fast web framework for Rust
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

use sqlx::{MySql, QueryBuilder, Row};

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct KlineData {
    pub t: i64,
    pub s: String,
    pub o: String,
    pub c: String,
    pub h: String,
    pub l: String,
    pub vr: String,
}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, async_graphql::SimpleObject)]
pub struct KlineDataVo {
    pub t: String,
    pub s: String,
    pub o: String,
    pub c: String,
    pub h: String,
    pub l: String,
    pub vr: String,
}

impl From<KlineData> for KlineDataVo {
    fn from(item: KlineData) -> Self {
        KlineDataVo {
            t: crate::commons::to_utc_datetime_string(item.t),
            s: item.s,
            o: item.o,
            c: item.c,
            h: item.h,
            l: item.l,
            vr: item.vr,
        }
    }
}

#[derive(async_graphql::InputObject, serde::Serialize, serde::Deserialize, validator::Validate)]
pub struct FetchKline {
    pub symbol: Option<String>,
    #[graphql(validator(minimum = 0))]
    pub skip: Option<u32>,
    #[graphql(validator(minimum = 0, maximum = 100))]
    pub limit: Option<u32>,
    pub order_by: Option<String>,
}

impl FetchKline {
    pub fn build(&self) -> QueryBuilder<'_, MySql> {
        let mut query_builder: QueryBuilder<MySql> = QueryBuilder::new(
            r#"
            SELECT f_symbol, f_open, f_close, f_high, f_low, f_time, f_vendor from t_kline where 1=1
        "#,
        );

        if let Some(symbol) = &self.symbol {
            query_builder.push(" AND f_symbol = ");
            query_builder.push_bind(symbol);
        }

        if let Some(order_by) = &self.order_by {
            use crate::core::mysql::Ordering;
            query_builder.push(Ordering::order_by(order_by));
        }

        if let Some(limit) = self.limit {
            query_builder.push(" limit ");
            query_builder.push_bind(limit);
        } else {
            query_builder.push(" limit ");
            query_builder.push_bind(10);
        }

        if let Some(skip) = self.skip {
            query_builder.push(" offset ");
            query_builder.push_bind(skip);
        }

        query_builder
    }

    pub fn from_row(r: sqlx::mysql::MySqlRow) -> Result<KlineDataVo, anyhow::Error> {
        #[rustfmt::skip]
        let r1: sqlx::types::BigDecimal = r.try_get(1).map_err(|e| anyhow::anyhow!(e))?;
        let r2: sqlx::types::BigDecimal = r.try_get(2).map_err(|e| anyhow::anyhow!(e))?;
        let r3: sqlx::types::BigDecimal = r.try_get(3).map_err(|e| anyhow::anyhow!(e))?;
        let r4: sqlx::types::BigDecimal = r.try_get(4).map_err(|e| anyhow::anyhow!(e))?;

        let r5: u64 = r.try_get(5).map_err(|e| anyhow::anyhow!(e))?;

        Ok(KlineDataVo {
            s: r.get(0),
            o: crate::commons::remove_trailing_zeros(&r1.to_string()),
            c: crate::commons::remove_trailing_zeros(&r2.to_string()),
            h: crate::commons::remove_trailing_zeros(&r3.to_string()),
            l: crate::commons::remove_trailing_zeros(&r4.to_string()),
            t: crate::commons::to_utc_datetime_string(r5 as i64),
            vr: r.get(6),
        })
    }
}