/
api_options.go
226 lines (191 loc) · 5.44 KB
/
api_options.go
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
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
// Copyright 2018 MaiCoin Technologies
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package max
import (
"time"
"github.com/maicoin/max-exchange-api-go/types"
)
var (
orderDescending = "desc"
orderAscending = "asc"
)
type Options map[string]interface{}
func defaultOptions() Options {
return make(map[string]interface{})
}
// ----------------------------------------------------------------------------
// CallOption represents the API parameters
type CallOption func(opt map[string]interface{})
// AsksLimit represents the asks_limit parameter
func AsksLimit(limit int32) CallOption {
return func(opt map[string]interface{}) {
opt["asks_limit"] = limit
}
}
// BidsLimit represents the bids_limit parameter
func BidsLimit(limit int32) CallOption {
return func(opt map[string]interface{}) {
opt["bids_limit"] = limit
}
}
// Limit represents the limit parameter
func Limit(limit int32) CallOption {
return func(opt map[string]interface{}) {
opt["limit"] = limit
}
}
// Timestamp represents the timestamp parameter
func Timestamp(timestamp int32) CallOption {
return func(opt map[string]interface{}) {
opt["timestamp"] = timestamp
}
}
// Time represents the timestamp parameter in Go time.Time format
func Time(t time.Time) CallOption {
return func(opt map[string]interface{}) {
opt["timestamp"] = t.Unix()
}
}
// From represents the from parameter
func From(from int32) CallOption {
return func(opt map[string]interface{}) {
opt["from"] = from
}
}
// FromTime represents the from parameter in Go time.Time format
func FromTime(from time.Time) CallOption {
return func(opt map[string]interface{}) {
opt["from"] = from.Unix()
}
}
// To represents the to parameter
func To(to int32) CallOption {
return func(opt map[string]interface{}) {
opt["to"] = to
}
}
// ToTime represents the to parameter
func ToTime(to time.Time) CallOption {
return func(opt map[string]interface{}) {
opt["to"] = to.Unix()
}
}
// OrderDesc represents the order_by=desc parameter
func OrderDesc() CallOption {
return func(opt map[string]interface{}) {
opt["order_by"] = orderDescending
}
}
// OrderAsc represents the order_by=asc parameter
func OrderAsc() CallOption {
return func(opt map[string]interface{}) {
opt["order_by"] = orderAscending
}
}
// Period represents the period parameter
func Period(period int32) CallOption {
return func(opt map[string]interface{}) {
opt["period"] = period
}
}
// PeriodDuration represents the period parameter in Go time.Duration format
func PeriodDuration(period time.Duration) CallOption {
return func(opt map[string]interface{}) {
opt["period"] = int64(period.Minutes())
}
}
// Currency represents the currency parameter
func Currency(currency string) CallOption {
return func(opt map[string]interface{}) {
opt["currency"] = currency
}
}
// Offset represents the offset parameter
func Offset(offset int32) CallOption {
return func(opt map[string]interface{}) {
opt["offset"] = offset
}
}
// DepositState represents the state parameter for deposit
func DepositState(state types.DepositState) CallOption {
return func(opt map[string]interface{}) {
opt["state"] = state
}
}
// WithdrawalState represents the state parameter for withdrawal
func WithdrawalState(state types.WithdrawalState) CallOption {
return func(opt map[string]interface{}) {
opt["state"] = state
}
}
// Price represents the price parameter
func Price(price types.Price) CallOption {
return func(opt map[string]interface{}) {
opt["price"] = price
}
}
// Prices represents the orders[price] parameter
func Prices(prices []types.Price) CallOption {
return func(opt map[string]interface{}) {
opt["orders[price]"] = prices
}
}
// StopPrice represents the stop_price parameter
func StopPrice(price types.Price) CallOption {
return func(opt map[string]interface{}) {
opt["stop_price"] = price
}
}
// StopPrices represents the orders[stop_price] parameter
func StopPrices(prices []types.Price) CallOption {
return func(opt map[string]interface{}) {
opt["orders[stop_price]"] = prices
}
}
// OrderType represents the ord_type parameter
func OrderType(t types.OrderType) CallOption {
return func(opt map[string]interface{}) {
opt["ord_type"] = t
}
}
// OrderTypes represents the orders[ord_type] parameter
func OrderTypes(t []types.OrderType) CallOption {
return func(opt map[string]interface{}) {
opt["orders[ord_type"] = t
}
}
// Pagination represents the pagination parameter
func Pagination(pagination bool) CallOption {
return func(opt map[string]interface{}) {
opt["pagination"] = pagination
}
}
// Page represents the page parameter
func Page(page int32) CallOption {
return func(opt map[string]interface{}) {
opt["page"] = page
}
}
// OrderSide represents the side parameter
func OrderSide(t types.OrderSide) CallOption {
return func(opt map[string]interface{}) {
opt["side"] = t
}
}
// Market represents the market parameter
func Market(market string) CallOption {
return func(opt map[string]interface{}) {
opt["market"] = market
}
}