From 0104c490d452baee6338a70c24d474234f1e4f46 Mon Sep 17 00:00:00 2001 From: Adrian Gallagher Date: Thu, 24 Mar 2016 21:00:36 +1100 Subject: [PATCH] Added OKCoin return interfaces for authenticated SPOT HTTP API requests. --- okcoinhttp.go | 730 +++++++++++++++++++++++++++++++++++--------------- 1 file changed, 521 insertions(+), 209 deletions(-) diff --git a/okcoinhttp.go b/okcoinhttp.go index 71c5c65a..0ee98530 100644 --- a/okcoinhttp.go +++ b/okcoinhttp.go @@ -1,6 +1,7 @@ package main import ( + "errors" "fmt" "github.com/gorilla/websocket" "log" @@ -86,7 +87,7 @@ type OKCoinBorrowInfo struct { type OKCoinBorrowOrder struct { Amount float64 `json:"amount"` - BorrowDate float64 `json:"borrow_date"` + BorrowDate int64 `json:"borrow_date"` BorrowID int64 `json:"borrow_id"` Days int64 `json:"days"` TradeAmount float64 `json:"deal_amount"` @@ -132,13 +133,6 @@ type OKCoinFuturesHoldAmount struct { ContractName string `json:"contract_name"` } -type OKCoinLendDepth struct { - Amount float64 `json:"amount"` - Days string `json:"days"` - Num int64 `json:"num"` - Rate float64 `json:"rate,string"` -} - type OKCoinFuturesExplosive struct { Amount float64 `json:"amount,string"` DateCreated string `json:"create_date"` @@ -508,16 +502,516 @@ func (o *OKCoin) GetFuturesExplosive(symbol, contractType string, status, curren return resp.Data } -func (o *OKCoin) GetUserInfo() { - err := o.SendAuthenticatedHTTPRequest("userinfo.do", url.Values{}) +type OKCoinUserInfo struct { + Info struct { + Funds struct { + Asset struct { + Net float64 `json:"net,string"` + Total float64 `json:"total,string"` + } `json:"asset"` + Borrow struct { + BTC float64 `json:"btc,string"` + LTC float64 `json:"ltc,string"` + USD float64 `json:"usd,string"` + } `json:"borrow"` + Free struct { + BTC float64 `json:"btc,string"` + LTC float64 `json:"ltc,string"` + USD float64 `json:"usd,string"` + } `json:"free"` + Freezed struct { + BTC float64 `json:"btc,string"` + LTC float64 `json:"ltc,string"` + USD float64 `json:"usd,string"` + } `json:"freezed"` + UnionFund struct { + BTC float64 `json:"btc,string"` + LTC float64 `json:"ltc,string"` + } `json:"union_fund"` + } `json:"funds"` + } `json:"info"` + Result bool `json:"result"` +} + +func (o *OKCoin) GetUserInfo() (OKCoinUserInfo, error) { + result := OKCoinUserInfo{} + err := o.SendAuthenticatedHTTPRequest("userinfo.do", url.Values{}, &result) if err != nil { - log.Println(err) + return result, err } + + return result, nil +} + +func (o *OKCoin) Trade(amount, price float64, symbol, orderType string) (int64, error) { + type Response struct { + Result bool `json:"result"` + OrderID int64 `json:"order_id"` + } + v := url.Values{} + v.Set("amount", strconv.FormatFloat(amount, 'f', -1, 64)) + v.Set("price", strconv.FormatFloat(price, 'f', -1, 64)) + v.Set("symbol", symbol) + v.Set("type", orderType) + + result := Response{} + + err := o.SendAuthenticatedHTTPRequest("trade.do", v, &result) + + if err != nil { + return 0, err + } + + if !result.Result { + return 0, errors.New("Unable to place order.") + } + + return result.OrderID, nil +} + +func (o *OKCoin) GetTradeHistory(symbol string, TradeID int64) ([]OKCoinTrades, error) { + result := []OKCoinTrades{} + v := url.Values{} + v.Set("symbol", symbol) + v.Set("since", strconv.FormatInt(TradeID, 10)) + + err := o.SendAuthenticatedHTTPRequest("trade_history.do", v, &result) + + if err != nil { + return nil, err + } + + return result, nil +} + +type OKCoinBatchTrade struct { + OrderInfo []struct { + OrderID int64 `json:"order_id"` + ErrorCode int64 `json:"error_code"` + } `json:"order_info"` + Result bool `json:"result"` +} + +func (o *OKCoin) BatchTrade(orderData string, symbol, orderType string) (OKCoinBatchTrade, error) { + v := url.Values{} + v.Set("orders_data", orderData) + v.Set("symbol", symbol) + v.Set("type", orderType) + result := OKCoinBatchTrade{} + + err := o.SendAuthenticatedHTTPRequest("batch_trade.do", v, &result) + + if err != nil { + return result, err + } + + return result, nil +} + +type OKCoinCancelOrderResponse struct { + Success string + Error string +} + +func (o *OKCoin) CancelOrder(orderID []int64, symbol string) (OKCoinCancelOrderResponse, error) { + v := url.Values{} + orders := []string{} + orderStr := "" + result := OKCoinCancelOrderResponse{} + + if len(orderID) > 1 { + for x := range orderID { + orders = append(orders, strconv.FormatInt(orderID[x], 10)) + } + orderStr = JoinStrings(orders, ",") + } else { + orderStr = strconv.FormatInt(orderID[0], 10) + } + + v.Set("order_id", orderStr) + v.Set("symbol", symbol) + + err := o.SendAuthenticatedHTTPRequest("cancel_order.do", v, &result) + + if err != nil { + return result, err + } + + return result, nil +} + +type OKCoinOrderInfo struct { + Amount float64 `json:"amount"` + AvgPrice float64 `json:"avg_price"` + Created int64 `json:"create_date"` + DealAmount float64 `json:"deal_amount"` + OrderID int64 `json:"order_id"` + OrdersID int64 `json:"orders_id"` + Price float64 `json:"price"` + Status int `json:"status"` + Symbol string `json:"symbol"` + Type string `json:"type"` +} + +func (o *OKCoin) GetOrderInfo(orderID int64, symbol string) ([]OKCoinOrderInfo, error) { + type Response struct { + Result bool `json:"result"` + Orders []OKCoinOrderInfo `json:"orders"` + } + v := url.Values{} + v.Set("symbol", symbol) + v.Set("order_id", strconv.FormatInt(orderID, 10)) + result := Response{} + + err := o.SendAuthenticatedHTTPRequest("order_info.do", v, &result) + + if err != nil { + return nil, err + } + + if result.Result != true { + return nil, errors.New("Unable to retrieve order info.") + } + + return result.Orders, nil +} + +func (o *OKCoin) GetOrderInfoBatch(orderID []int64, symbol string) ([]OKCoinOrderInfo, error) { + type Response struct { + Result bool `json:"result"` + Orders []OKCoinOrderInfo `json:"orders"` + } + + orders := []string{} + for x := range orderID { + orders = append(orders, strconv.FormatInt(orderID[x], 10)) + } + + v := url.Values{} + v.Set("symbol", symbol) + v.Set("order_id", JoinStrings(orders, ",")) + result := Response{} + + err := o.SendAuthenticatedHTTPRequest("orders_info.do", v, &result) + + if err != nil { + return nil, err + } + + if result.Result != true { + return nil, errors.New("Unable to retrieve order info.") + } + + return result.Orders, nil +} + +type OKCoinOrderHistory struct { + CurrentPage int `json:"current_page"` + Orders []OKCoinOrderInfo `json:"orders"` + PageLength int `json:"page_length"` + Result bool `json:"result"` + Total int `json:"total"` +} + +func (o *OKCoin) GetOrderHistory(pageLength, currentPage int64, status, symbol string) (OKCoinOrderHistory, error) { + v := url.Values{} + v.Set("symbol", symbol) + v.Set("status", status) + v.Set("current_page", strconv.FormatInt(currentPage, 10)) + v.Set("page_length", strconv.FormatInt(pageLength, 10)) + result := OKCoinOrderHistory{} + + err := o.SendAuthenticatedHTTPRequest("order_history.do", v, &result) + + if err != nil { + return result, err + } + + return result, nil +} + +type OKCoinWithdrawalResponse struct { + WithdrawID int `json:"withdraw_id"` + Result bool `json:"result"` +} + +func (o *OKCoin) Withdrawal(symbol string, fee float64, tradePWD, address string, amount float64) (int, error) { + v := url.Values{} + v.Set("symbol", symbol) + + if fee != 0 { + v.Set("chargefee", strconv.FormatFloat(fee, 'f', -1, 64)) + } + v.Set("trade_pwd", tradePWD) + v.Set("withdraw_address", address) + v.Set("withdraw_amount", strconv.FormatFloat(amount, 'f', -1, 64)) + result := OKCoinWithdrawalResponse{} + + err := o.SendAuthenticatedHTTPRequest("withdraw.do", v, &result) + + if err != nil { + return 0, err + } + + if !result.Result { + return 0, errors.New("Unable to process withdrawal request.") + } + + return result.WithdrawID, nil +} + +func (o *OKCoin) CancelWithdrawal(symbol string, withdrawalID int64) (int, error) { + v := url.Values{} + v.Set("symbol", symbol) + v.Set("withdrawal_id", strconv.FormatInt(withdrawalID, 10)) + result := OKCoinWithdrawalResponse{} + + err := o.SendAuthenticatedHTTPRequest("cancel_withdraw.do", v, &result) + + if err != nil { + return 0, err + } + + if !result.Result { + return 0, errors.New("Unable to process withdrawal cancel request.") + } + + return result.WithdrawID, nil +} + +type OKCoinWithdrawInfo struct { + Address string `json:"address"` + Amount float64 `json:"amount"` + Created int64 `json:"created_date"` + ChargeFee float64 `json:"chargefee"` + Status int `json:"status"` + WithdrawID int64 `json:"withdraw_id"` +} + +func (o *OKCoin) GetWithdrawalInfo(symbol string, withdrawalID int64) ([]OKCoinWithdrawInfo, error) { + type Response struct { + Result bool + Withdraw []OKCoinWithdrawInfo `json:"withdraw"` + } + v := url.Values{} + v.Set("symbol", symbol) + v.Set("withdrawal_id", strconv.FormatInt(withdrawalID, 10)) + result := Response{} + + err := o.SendAuthenticatedHTTPRequest("withdraw_info.do", v, &result) + + if err != nil { + return nil, err + } + + if !result.Result { + return nil, errors.New("Unable to process withdrawal cancel request.") + } + + return result.Withdraw, nil +} + +type OKCoinOrderFeeInfo struct { + Fee float64 `json:"fee,string"` + OrderID int64 `json:"order_id"` + Type string `json:"type"` +} + +func (o *OKCoin) GetOrderFeeInfo(symbol string, orderID int64) (OKCoinOrderFeeInfo, error) { + type Response struct { + Data OKCoinOrderFeeInfo `json:"data"` + Result bool `json:"result"` + } + + v := url.Values{} + v.Set("symbol", symbol) + v.Set("order_id", strconv.FormatInt(orderID, 10)) + result := Response{} + + err := o.SendAuthenticatedHTTPRequest("order_fee.do", v, &result) + + if err != nil { + return result.Data, err + } + + if !result.Result { + return result.Data, errors.New("Unable to get order fee info.") + } + + return result.Data, nil +} + +type OKCoinLendDepth struct { + Amount float64 `json:"amount"` + Days string `json:"days"` + Num int64 `json:"num"` + Rate float64 `json:"rate,string"` +} + +func (o *OKCoin) GetLendDepth(symbol string) ([]OKCoinLendDepth, error) { + type Response struct { + LendDepth []OKCoinLendDepth `json:"lend_depth"` + } + + v := url.Values{} + v.Set("symbol", symbol) + result := Response{} + + err := o.SendAuthenticatedHTTPRequest("lend_depth.do", v, &result) + + if err != nil { + return nil, err + } + + return result.LendDepth, nil +} + +func (o *OKCoin) GetBorrowInfo(symbol string) (OKCoinBorrowInfo, error) { + v := url.Values{} + v.Set("symbol", symbol) + result := OKCoinBorrowInfo{} + + err := o.SendAuthenticatedHTTPRequest("borrows_info.do", v, &result) + + if err != nil { + return result, nil + } + + return result, nil +} + +type OKCoinBorrowResponse struct { + Result bool `json:"result"` + BorrowID int `json:"borrow_id"` +} + +func (o *OKCoin) Borrow(symbol, days string, amount, rate float64) (int, error) { + v := url.Values{} + v.Set("symbol", symbol) + v.Set("days", days) + v.Set("amount", strconv.FormatFloat(amount, 'f', -1, 64)) + v.Set("rate", strconv.FormatFloat(rate, 'f', -1, 64)) + result := OKCoinBorrowResponse{} + + err := o.SendAuthenticatedHTTPRequest("borrow_money.do", v, &result) + + if err != nil { + return 0, err + } + + if !result.Result { + return 0, errors.New("Unable to borrow.") + } + + return result.BorrowID, nil +} + +func (o *OKCoin) CancelBorrow(symbol string, borrowID int64) (bool, error) { + v := url.Values{} + v.Set("symbol", symbol) + v.Set("borrow_id", strconv.FormatInt(borrowID, 10)) + result := OKCoinBorrowResponse{} + + err := o.SendAuthenticatedHTTPRequest("cancel_borrow.do", v, &result) + + if err != nil { + return false, err + } + + if !result.Result { + return false, errors.New("Unable to cancel borrow.") + } + + return true, nil +} + +func (o *OKCoin) GetBorrowOrderInfo(borrowID int64) (OKCoinBorrowInfo, error) { + type Response struct { + Result bool `json:"result"` + BorrowOrder OKCoinBorrowInfo `json:"borrow_order"` + } + + v := url.Values{} + v.Set("borrow_id", strconv.FormatInt(borrowID, 10)) + result := Response{} + err := o.SendAuthenticatedHTTPRequest("borrow_order_info.do", v, &result) + + if err != nil { + return result.BorrowOrder, err + } + + if !result.Result { + return result.BorrowOrder, errors.New("Unable to get borrow info.") + } + + return result.BorrowOrder, nil +} + +func (o *OKCoin) GetRepaymentInfo(borrowID int64) (bool, error) { + v := url.Values{} + v.Set("borrow_id", strconv.FormatInt(borrowID, 10)) + result := OKCoinBorrowResponse{} + + err := o.SendAuthenticatedHTTPRequest("repayment.do", v, &result) + + if err != nil { + return false, err + } + + if !result.Result { + return false, errors.New("Unable to get repayment info.") + } + + return true, nil +} + +func (o *OKCoin) GetUnrepaymentsInfo(symbol string, currentPage, pageLength int) ([]OKCoinBorrowOrder, error) { + type Response struct { + Unrepayments []OKCoinBorrowOrder `json:"unrepayments"` + Result bool `json:"result"` + } + v := url.Values{} + v.Set("symbol", symbol) + v.Set("current_page", strconv.Itoa(currentPage)) + v.Set("page_length", strconv.Itoa(pageLength)) + result := Response{} + err := o.SendAuthenticatedHTTPRequest("unrepayments_info.do", v, &result) + + if err != nil { + return nil, err + } + + if !result.Result { + return nil, errors.New("Unable to get unrepayments info.") + } + + return result.Unrepayments, nil +} + +func (o *OKCoin) GetAccountRecords(symbol string, recType, currentPage, pageLength int) ([]OKCoinAccountRecords, error) { + type Response struct { + Records []OKCoinAccountRecords `json:"records"` + Symbol string `json:"symbol"` + } + v := url.Values{} + v.Set("symbol", symbol) + v.Set("type", strconv.Itoa(recType)) + v.Set("current_page", strconv.Itoa(currentPage)) + v.Set("page_length", strconv.Itoa(pageLength)) + result := Response{} + + err := o.SendAuthenticatedHTTPRequest("account_records.do", v, &result) + + if err != nil { + return nil, err + } + + return result.Records, nil } func (o *OKCoin) GetFuturesUserInfo() { - err := o.SendAuthenticatedHTTPRequest("future_userinfo.do", url.Values{}) + err := o.SendAuthenticatedHTTPRequest("future_userinfo.do", url.Values{}, nil) if err != nil { log.Println(err) @@ -528,21 +1022,7 @@ func (o *OKCoin) GetFuturesPosition(symbol, contractType string) { v := url.Values{} v.Set("symbol", symbol) v.Set("contract_type", contractType) - err := o.SendAuthenticatedHTTPRequest("future_userinfo.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) Trade(amount, price float64, symbol, orderType string) { - v := url.Values{} - v.Set("amount", strconv.FormatFloat(amount, 'f', -1, 64)) - v.Set("price", strconv.FormatFloat(price, 'f', -1, 64)) - v.Set("symbol", symbol) - v.Set("type", orderType) - - err := o.SendAuthenticatedHTTPRequest("trade.do", v) + err := o.SendAuthenticatedHTTPRequest("future_userinfo.do", v, nil) if err != nil { log.Println(err) @@ -559,20 +1039,7 @@ func (o *OKCoin) FuturesTrade(amount, price float64, matchPrice, leverage int64, v.Set("match_price", strconv.FormatInt(matchPrice, 10)) v.Set("lever_rate", strconv.FormatInt(leverage, 10)) - err := o.SendAuthenticatedHTTPRequest("future_trade.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) BatchTrade(orderData string, symbol, orderType string) { - v := url.Values{} //to-do batch trade support for orders_data - v.Set("orders_data", orderData) - v.Set("symbol", symbol) - v.Set("type", orderType) - - err := o.SendAuthenticatedHTTPRequest("batch_trade.do", v) + err := o.SendAuthenticatedHTTPRequest("future_trade.do", v, nil) if err != nil { log.Println(err) @@ -586,19 +1053,7 @@ func (o *OKCoin) FuturesBatchTrade(orderData, symbol, contractType string, lever v.Set("orders_data", orderData) v.Set("lever_rate", strconv.FormatInt(leverage, 10)) - err := o.SendAuthenticatedHTTPRequest("future_batch_trade.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) CancelOrder(orderID int64, symbol string) { - v := url.Values{} - v.Set("orders_id", strconv.FormatInt(orderID, 10)) - v.Set("symbol", symbol) - - err := o.SendAuthenticatedHTTPRequest("cancel_order.do", v) + err := o.SendAuthenticatedHTTPRequest("future_batch_trade.do", v, nil) if err != nil { log.Println(err) @@ -611,19 +1066,7 @@ func (o *OKCoin) CancelFuturesOrder(orderID int64, symbol, contractType string) v.Set("contract_type", contractType) v.Set("order_id", strconv.FormatInt(orderID, 10)) - err := o.SendAuthenticatedHTTPRequest("future_cancel.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) GetOrderInfo(orderID int64, symbol string) { - v := url.Values{} - v.Set("symbol", symbol) - v.Set("order_id", strconv.FormatInt(orderID, 10)) - - err := o.SendAuthenticatedHTTPRequest("order_info.do", v) + err := o.SendAuthenticatedHTTPRequest("future_cancel.do", v, nil) if err != nil { log.Println(err) @@ -639,20 +1082,7 @@ func (o *OKCoin) GetFuturesOrderInfo(orderID, status, currentPage, pageLength in v.Set("current_page", strconv.FormatInt(currentPage, 10)) v.Set("page_length", strconv.FormatInt(pageLength, 10)) - err := o.SendAuthenticatedHTTPRequest("future_order_info.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) GetOrdersInfo(orderID int64, orderType string, symbol string) { - v := url.Values{} - v.Set("orders_id", strconv.FormatInt(orderID, 10)) - v.Set("type", orderType) - v.Set("symbol", symbol) - - err := o.SendAuthenticatedHTTPRequest("orders_info.do", v) + err := o.SendAuthenticatedHTTPRequest("future_order_info.do", v, nil) if err != nil { log.Println(err) @@ -665,49 +1095,7 @@ func (o *OKCoin) GetFutureOrdersInfo(orderID int64, contractType, symbol string) v.Set("contract_type", contractType) v.Set("symbol", symbol) - err := o.SendAuthenticatedHTTPRequest("future_orders_info.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) GetOrderHistory(orderID, pageLength, currentPage int64, orderType string, status, symbol string) { - v := url.Values{} - v.Set("orders_id", strconv.FormatInt(orderID, 10)) - v.Set("type", orderType) - v.Set("symbol", symbol) - v.Set("status", status) - v.Set("current_page", strconv.FormatInt(currentPage, 10)) - v.Set("page_length", strconv.FormatInt(pageLength, 10)) - - err := o.SendAuthenticatedHTTPRequest("order_history.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) Withdrawal(symbol string, fee float64, tradePWD, address string, amount float64) { - v := url.Values{} - v.Set("symbol", symbol) - v.Set("chargefee", strconv.FormatFloat(fee, 'f', -1, 64)) - v.Set("trade_pwd", tradePWD) - v.Set("withdraw_address", address) - v.Set("withdraw_amount", strconv.FormatFloat(amount, 'f', -1, 64)) - - err := o.SendAuthenticatedHTTPRequest("withdraw.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) CancelWithdrawal(withdrawalID int64) { - v := url.Values{} - v.Set("withdrawal_id", strconv.FormatInt(withdrawalID, 10)) - - err := o.SendAuthenticatedHTTPRequest("cancel_withdraw.do", v) + err := o.SendAuthenticatedHTTPRequest("future_orders_info.do", v, nil) if err != nil { log.Println(err) @@ -717,7 +1105,7 @@ func (o *OKCoin) CancelWithdrawal(withdrawalID int64) { func (o *OKCoin) GetFuturesUserInfo4Fix() { v := url.Values{} - err := o.SendAuthenticatedHTTPRequest("future_userinfo_4fix.do", v) + err := o.SendAuthenticatedHTTPRequest("future_userinfo_4fix.do", v, nil) if err != nil { log.Println(err) @@ -730,96 +1118,14 @@ func (o *OKCoin) GetFuturesUserPosition4Fix(symbol, contractType string) { v.Set("contract_type", contractType) v.Set("type", strconv.FormatInt(1, 10)) - err := o.SendAuthenticatedHTTPRequest("future_position_4fix.do", v) + err := o.SendAuthenticatedHTTPRequest("future_position_4fix.do", v, nil) if err != nil { log.Println(err) } } -func (o *OKCoin) GetBorrowInfo(symbol string) { - v := url.Values{} - v.Set("symbol", symbol) - - err := o.SendAuthenticatedHTTPRequest("borrows_info.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) Borrow(symbol, days string, amount, rate float64) { - v := url.Values{} - v.Set("symbol", symbol) - v.Set("days", days) - v.Set("amount", strconv.FormatFloat(amount, 'f', -1, 64)) - v.Set("rate", strconv.FormatFloat(rate, 'f', -1, 64)) - err := o.SendAuthenticatedHTTPRequest("borrow_money.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) CancelBorrow(symbol string, borrowID int64) { - v := url.Values{} - v.Set("symbol", symbol) - v.Set("borrow_id", strconv.FormatInt(borrowID, 10)) - err := o.SendAuthenticatedHTTPRequest("cancel_borrow.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) GetBorrowOrderInfo(borrowID int64) { - v := url.Values{} - v.Set("borrow_id", strconv.FormatInt(borrowID, 10)) - err := o.SendAuthenticatedHTTPRequest("borrow_order_info.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) GetRepaymentInfo(borrowID int64) { - v := url.Values{} - v.Set("borrow_id", strconv.FormatInt(borrowID, 10)) - err := o.SendAuthenticatedHTTPRequest("repayment.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) GetUnrepaymentsInfo(symbol string, currentPage, pageLength int) { - v := url.Values{} - v.Set("symbol", symbol) - v.Set("current_page", strconv.Itoa(currentPage)) - v.Set("page_length", strconv.Itoa(pageLength)) - - err := o.SendAuthenticatedHTTPRequest("unrepayments_info.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) GetAccountRecords(symbol string, recType, currentPage, pageLength int) { - v := url.Values{} - v.Set("symbol", symbol) - v.Set("type", strconv.Itoa(recType)) - v.Set("current_page", strconv.Itoa(currentPage)) - v.Set("page_length", strconv.Itoa(pageLength)) - - err := o.SendAuthenticatedHTTPRequest("account_records.do", v) - - if err != nil { - log.Println(err) - } -} - -func (o *OKCoin) SendAuthenticatedHTTPRequest(method string, v url.Values) (err error) { +func (o *OKCoin) SendAuthenticatedHTTPRequest(method string, v url.Values, result interface{}) (err error) { v.Set("api_key", o.PartnerID) hasher := GetMD5([]byte(v.Encode() + "&secret_key=" + o.SecretKey)) v.Set("sign", strings.ToUpper(HexEncodeToString(hasher))) @@ -844,6 +1150,12 @@ func (o *OKCoin) SendAuthenticatedHTTPRequest(method string, v url.Values) (err log.Printf("Recieved raw: \n%s\n", resp) } + err = JSONDecode([]byte(resp), &result) + + if err != nil { + return errors.New("Unable to JSON Unmarshal response.") + } + return nil }