rsgmo 0.2.2

GMOコインのRust用APIライブラリ.
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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::{
    v1::api::{GmoApi, Pagination},
    request::AccessLevel,
    utils,
};

use anyhow::Result;
use serde::{Deserialize, Serialize};

const PATH: &str = "/v1/activeOrders";

impl GmoApi {
    pub async fn get_active_orders(&self, parameters: GetActiveOrdersParameters) -> Result<GetActiveOrdersResponse> {
        self.get(PATH, Some(parameters), AccessLevel::Private).await
    }
}


#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct GetActiveOrdersParameters {
    symbol: String,
    page: Option<i32>,
    count: Option<i32>,
}

impl GetActiveOrdersParameters {
    pub fn new(symbol: &str) -> Self {
        GetActiveOrdersParameters {
            symbol: symbol.to_string(),
            page: None,
            count: None,
        }
    }

    pub fn with_page(mut self, page: i32) -> Self {
        self.page = Some(page);
        self
    }

    pub fn with_count(mut self, count: i32) -> Self {
        self.count = Some(count);
        self
    }
}

#[derive(Debug, Clone, Deserialize)]
pub struct GetActiveOrdersResponse {
    status: i32,
    data: ActiveOrdersData,
    responsetime: String,
}

impl GetActiveOrdersResponse {
    pub fn status(&self) -> i32 {
        self.status
    }
    pub fn data(&self) -> &ActiveOrdersData {
        &self.data
    }
    pub fn responsetime(&self) -> &str {
        &self.responsetime
    }
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActiveOrdersData {
    pagination: Option<Pagination>,
    list: Option<Vec<ActiveOrders>>,
}

impl ActiveOrdersData {
    pub fn pagination(&self) -> &Option<Pagination> {
        &self.pagination
    }
    pub fn list(&self) -> &Option<Vec<ActiveOrders>> {
        &self.list
    }
}

#[derive(Debug, Clone, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ActiveOrders {
    order_id: i64,
    root_order_id: i64,
    symbol: String,
    side: String,
    order_type: String,
    settle_type: String,
    #[serde(deserialize_with = "utils::deserialize_f64")]
    size: f64,
    #[serde(deserialize_with = "utils::deserialize_f64")]
    executed_size: f64,
    #[serde(deserialize_with = "utils::deserialize_f64")]
    pride: f64,
    #[serde(deserialize_with = "utils::deserialize_f64")]
    losscut_price: f64,
    status: String,
    time_in_force: String,
    timestamp: String,
}

impl ActiveOrders {
    pub fn order_id(&self) -> i64 {
        self.order_id
    }
    pub fn root_order_id(&self) -> i64 {
        self.root_order_id
    }
    pub fn symbol(&self) -> &str {
        &self.symbol
    }
    pub fn side(&self) -> &str {
        &self.side
    }
    pub fn order_type(&self) -> &str {
        &self.order_type
    }
    pub fn settle_type(&self) -> &str {
        &self.settle_type
    }
    pub fn size(&self) -> f64 {
        self.size
    }
    pub fn executed_size(&self) -> f64 {
        self.executed_size
    }
    pub fn pride(&self) -> f64 {
        self.pride
    }
    pub fn losscut_price(&self) -> f64 {
        self.losscut_price
    }
    pub fn status(&self) -> &str {
        &self.status
    }
    pub fn time_in_force(&self) -> &str {
        &self.time_in_force
    }
    pub fn timestamp(&self) -> &str {
        &self.timestamp
    }
}