/
allPages.go
147 lines (135 loc) · 4.94 KB
/
allPages.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
package conn
import (
"fmt"
"time"
"github.com/cryptomkt/cryptomkt-go/args"
)
// GetTradesAllPages returns a pointer to a Trades struct with the data given
// by the api and an error message. It returns (nil, error) when an error
// is raised and (*Trades, nil) when the operation is successful. If end
// argument is not provided, the maximum data amount will be trucated when
// it raises more than 100 elements. It is not sure it will give you
// exactly 100 TradeData Data.
//
// List of accepted Arguments:
// - required: Market (string)
// - optional: Start (string YYYY-MM-DD), End (string YYYY-MM-DD)
// https://developers.cryptomkt.com/es/#trades
func (client *Client) GetTradesAllPages(arguments ...args.Argument) ([]TradeData, error) {
req, err := makeReq([]string{"market"}, arguments...)
if err != nil {
return nil, fmt.Errorf("Error in GetTradesAllPages: %s", err)
}
neededArguments := []args.Argument{args.Page(0), args.Limit(100)}
argsMap := req.GetArguments()
neededArguments = append(neededArguments, args.Market(argsMap["market"]))
if val, ok := argsMap["start"]; ok {
neededArguments = append(neededArguments, args.Start(val))
}
if val, ok := argsMap["end"]; ok {
neededArguments = append(neededArguments, args.End(val))
}
tPage, err := client.GetTrades(neededArguments...)
if err != nil {
return nil, fmt.Errorf("Error in GetTrades: %s", err)
}
allt := make([]TradeData, len(tPage.Data))
copy(allt, tPage.Data)
for tPage, err = tPage.GetNext(); err == nil; tPage, err = tPage.GetNext() {
time.Sleep(2 * time.Second) //because the server only accepts 30 calls per minute.
allt = append(allt, tPage.Data...)
// When the data length raises 100 elements or more when "end" parameter is not provided,
// it breaks. This block limit the number of pages
if _, ok := argsMap["end"]; !ok {
if len(allt) > 100 {
break
}
}
}
return allt, nil
}
// GetActiveOrdersAllPages gets all the actives orders of the client in a given market.
// returns an array of orders.
//
// List of accepted Arguments:
// - required: Market (string)
// - optional: none
// https://developers.cryptomkt.com/es/#ordenes-activas
func (client *Client) GetActiveOrdersAllPages(arguments ...args.Argument) ([]Order, error) {
req, err := makeReq([]string{"market"}, arguments...)
if err != nil {
return nil, fmt.Errorf("Error in GetAllActiveOrders: %s", err)
}
neededArguments := []args.Argument{args.Page(0), args.Limit(100)}
argsMap := req.GetArguments()
val := argsMap["market"]
neededArguments = append(neededArguments, args.Market(val))
oList, err := client.GetActiveOrders(neededArguments...)
if err != nil {
return nil, fmt.Errorf("Error in GetActiveOrdersAllPages: %s", err)
}
return getAllOrders(oList), nil
}
// GetExecutedOrdersAllPages gets all executed orders of the client in a given market
//
// List of accepted Arguments:
// - required: Market (string)
// - optional: none
// https://developers.cryptomkt.com/es/#ordenes-ejecutadas
func (client *Client) GetExecutedOrdersAllPages(arguments ...args.Argument) ([]Order, error) {
req, err := makeReq([]string{"market"}, arguments...)
if err != nil {
return nil, fmt.Errorf("Error in GetExecutedOrdersAllPages: %s", err)
}
neededArguments := []args.Argument{args.Page(0), args.Limit(100)}
argsMap := req.GetArguments()
val := argsMap["market"]
neededArguments = append(neededArguments, args.Market(val))
oList, err := client.GetExecutedOrders(neededArguments...)
if err != nil {
return nil, fmt.Errorf("Error in GetAllExecutedOrders: %s", err)
}
return getAllOrders(oList), nil
}
func getAllOrders(oList *OrderList) []Order {
allo := make([]Order, len(oList.Data))
copy(allo, oList.Data)
for oList, err := oList.GetNext(); err == nil; oList, err = oList.GetNext() {
time.Sleep(2 * time.Second)
oList.setClientInOrders()
allo = append(allo, oList.Data...)
// When the data pages length raises 100 elements or more,
// it breaks. This "if" block limit the number of pages
if len(allo) > 100 {
break
}
}
return allo
}
// GetAllTransactions returns an array of transactions made in cryptomkt.
//
// List of arguments:
// required: currency (string)
func (client *Client) GetAllTransactions(argus ...args.Argument) ([]Transaction, error) {
req, err := makeReq([]string{"currency"}, argus...)
if err != nil {
return nil, fmt.Errorf("Error in GetAllTransactions: %s", err)
}
neededArguments := []args.Argument{args.Page(0), args.Limit(100)}
argsMap := req.GetArguments()
neededArguments = append(neededArguments, args.Currency(argsMap["currency"]))
trans, err := client.GetTransactions(neededArguments...)
if err != nil {
return nil, fmt.Errorf("Error in GetTransactions: %s", err)
}
allTrans := make([]Transaction, len(trans.Data))
copy(allTrans, trans.Data)
for trans, err = trans.GetNext(); err == nil; trans, err = trans.GetNext() {
time.Sleep(2 * time.Second)
allTrans = append(allTrans, trans.Data...)
if len(allTrans) > 100 {
break
}
}
return allTrans, nil
}