d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-06-08 07:26:48 +00:00
Code Issues Packages Projects Releases Wiki Activity

Engine QA - Order update (#372)

Browse Source 
Engine QA - Order update
This commit is contained in:
Ryan O'Hara-Reid
2019-10-30 14:06:48 +11:00
committed by Adrian Gallagher
parent 242b02c382
commit 63a9e9fcb1
89 changed files with 3077 additions and 2876 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
exchanges/btcmarkets/btcmarkets_test.go
View File

@@ -8,6 +8,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/config"
"github.com/thrasher-corp/gocryptotrader/currency"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
)
var b BTCMarkets
@@ -85,7 +86,7 @@ func TestGetTrades(t *testing.T) {
func TestNewOrder(t *testing.T) {
t.Parallel()
_, err := b.NewOrder("AUD", "BTC", 0, 0, "Bid",
exchange.LimitOrderType.ToLower().ToString(), "testTest")
order.Limit.Lower(), "testTest")
if err == nil {
t.Error("NewOrder() Expected error")
}
@@ -294,8 +295,8 @@ func TestGetActiveOrders(t *testing.T) {
b.SetDefaults()
TestSetup(t)
var getOrdersRequest = exchange.GetOrdersRequest{
OrderType: exchange.AnyOrderType,
var getOrdersRequest = order.GetOrdersRequest{
OrderType: order.AnyType,
}
_, err := b.GetActiveOrders(&getOrdersRequest)
@@ -310,8 +311,8 @@ func TestGetOrderHistory(t *testing.T) {
b.SetDefaults()
TestSetup(t)
var getOrdersRequest = exchange.GetOrdersRequest{
OrderType: exchange.AnyOrderType,
var getOrdersRequest = order.GetOrdersRequest{
OrderType: order.AnyType,
Currencies: []currency.Pair{currency.NewPair(currency.LTC,
currency.BTC)},
}
@@ -338,14 +339,14 @@ func TestSubmitOrder(t *testing.T) {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
var orderSubmission = &exchange.OrderSubmission{
var orderSubmission = &order.Submit{
Pair: currency.Pair{
Delimiter: "-",
Base: currency.BTC,
Quote: currency.LTC,
},
OrderSide: exchange.BuyOrderSide,
OrderType: exchange.LimitOrderType,
OrderSide: order.Buy,
OrderType: order.Limit,
Price: 1,
Amount: 1,
ClientID: "meowOrder",
@@ -368,7 +369,7 @@ func TestCancelExchangeOrder(t *testing.T) {
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &exchange.OrderCancellation{
var orderCancellation = &order.Cancel{
OrderID: "1",
WalletAddress: "1F5zVDgNjorJ51oGebSvNCrSAHpwGkUdDB",
AccountID: "1",
@@ -394,7 +395,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &exchange.OrderCancellation{
var orderCancellation = &order.Cancel{
OrderID: "1",
WalletAddress: "1F5zVDgNjorJ51oGebSvNCrSAHpwGkUdDB",
AccountID: "1",
@@ -410,13 +411,13 @@ func TestCancelAllExchangeOrders(t *testing.T) {
t.Errorf("Could not cancel orders: %v", err)
}
if len(resp.OrderStatus) > 0 {
t.Errorf("%v orders failed to cancel", len(resp.OrderStatus))
if len(resp.Status) > 0 {
t.Errorf("%v orders failed to cancel", len(resp.Status))
}
}
func TestModifyOrder(t *testing.T) {
_, err := b.ModifyOrder(&exchange.ModifyOrder{})
_, err := b.ModifyOrder(&order.Modify{})
if err == nil {
t.Error("ModifyOrder() Expected error")
}

136
exchanges/btcmarkets/btcmarkets_wrapper.go
View File

@@ -13,6 +13,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/currency"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-corp/gocryptotrader/exchanges/protocol"
"github.com/thrasher-corp/gocryptotrader/exchanges/request"
@@ -340,33 +341,29 @@ func (b *BTCMarkets) GetExchangeHistory(p currency.Pair, assetType asset.Item) (
}
// SubmitOrder submits a new order
func (b *BTCMarkets) SubmitOrder(order *exchange.OrderSubmission) (exchange.SubmitOrderResponse, error) {
var submitOrderResponse exchange.SubmitOrderResponse
if order == nil {
return submitOrderResponse, exchange.ErrOrderSubmissionIsNil
}
if err := order.Validate(); err != nil {
func (b *BTCMarkets) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
var submitOrderResponse order.SubmitResponse
if err := s.Validate(); err != nil {
return submitOrderResponse, err
}
if strings.EqualFold(order.OrderSide.ToString(), exchange.SellOrderSide.ToString()) {
order.OrderSide = exchange.AskOrderSide
if strings.EqualFold(s.OrderSide.String(), order.Sell.String()) {
s.OrderSide = order.Ask
}
if strings.EqualFold(order.OrderSide.ToString(), exchange.BuyOrderSide.ToString()) {
order.OrderSide = exchange.BuyOrderSide
if strings.EqualFold(s.OrderSide.String(), order.Buy.String()) {
s.OrderSide = order.Bid
}
response, err := b.NewOrder(order.Pair.Base.Upper().String(),
order.Pair.Quote.Upper().String(),
order.Price,
order.Amount,
order.OrderSide.ToString(),
order.OrderType.ToString(),
order.ClientID)
response, err := b.NewOrder(s.Pair.Base.Upper().String(),
s.Pair.Quote.Upper().String(),
s.Price,
s.Amount,
s.OrderSide.String(),
s.OrderType.String(),
s.ClientID)
if response > 0 {
submitOrderResponse.OrderID = fmt.Sprintf("%v", response)
submitOrderResponse.OrderID = strconv.FormatInt(response, 10)
}
if err == nil {
@@ -378,12 +375,12 @@ func (b *BTCMarkets) SubmitOrder(order *exchange.OrderSubmission) (exchange.Subm
// ModifyOrder will allow of changing orderbook placement and limit to
// market conversion
func (b *BTCMarkets) ModifyOrder(action *exchange.ModifyOrder) (string, error) {
func (b *BTCMarkets) ModifyOrder(action *order.Modify) (string, error) {
return "", common.ErrFunctionNotSupported
}
// CancelOrder cancels an order by its corresponding ID number
func (b *BTCMarkets) CancelOrder(order *exchange.OrderCancellation) error {
func (b *BTCMarkets) CancelOrder(order *order.Cancel) error {
orderIDInt, err := strconv.ParseInt(order.OrderID, 10, 64)
if err != nil {
return err
@@ -394,9 +391,9 @@ func (b *BTCMarkets) CancelOrder(order *exchange.OrderCancellation) error {
}
// CancelAllOrders cancels all orders associated with a currency pair
func (b *BTCMarkets) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.CancelAllOrdersResponse, error) {
cancelAllOrdersResponse := exchange.CancelAllOrdersResponse{
OrderStatus: make(map[string]string),
func (b *BTCMarkets) CancelAllOrders(_ *order.Cancel) (order.CancelAllResponse, error) {
cancelAllOrdersResponse := order.CancelAllResponse{
Status: make(map[string]string),
}
openOrders, err := b.GetOpenOrders()
if err != nil {
@@ -416,7 +413,7 @@ func (b *BTCMarkets) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Ca
for i := range orders {
if !orders[i].Success {
cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(orders[i].ID, 10)] = orders[i].ErrorMessage
cancelAllOrdersResponse.Status[strconv.FormatInt(orders[i].ID, 10)] = orders[i].ErrorMessage
}
}
}
@@ -424,8 +421,8 @@ func (b *BTCMarkets) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Ca
}
// GetOrderInfo returns information on a current open order
func (b *BTCMarkets) GetOrderInfo(orderID string) (exchange.OrderDetail, error) {
var OrderDetail exchange.OrderDetail
func (b *BTCMarkets) GetOrderInfo(orderID string) (order.Detail, error) {
var OrderDetail order.Detail
o, err := strconv.ParseInt(orderID, 10, 64)
if err != nil {
@@ -446,14 +443,14 @@ func (b *BTCMarkets) GetOrderInfo(orderID string) (exchange.OrderDetail, error)
}
for i := range orders {
var side exchange.OrderSide
if strings.EqualFold(orders[i].OrderSide, exchange.AskOrderSide.ToString()) {
side = exchange.SellOrderSide
} else if strings.EqualFold(orders[i].OrderSide, exchange.BidOrderSide.ToString()) {
side = exchange.BuyOrderSide
var side order.Side
if strings.EqualFold(orders[i].OrderSide, order.Ask.String()) {
side = order.Sell
} else if strings.EqualFold(orders[i].OrderSide, order.Bid.String()) {
side = order.Buy
}
orderDate := time.Unix(int64(orders[i].CreationTime), 0)
orderType := exchange.OrderType(strings.ToUpper(orders[i].OrderType))
orderType := order.Type(strings.ToUpper(orders[i].OrderType))
OrderDetail.Amount = orders[i].Volume
OrderDetail.OrderDate = orderDate
@@ -463,7 +460,7 @@ func (b *BTCMarkets) GetOrderInfo(orderID string) (exchange.OrderDetail, error)
OrderDetail.OrderSide = side
OrderDetail.OrderType = orderType
OrderDetail.Price = orders[i].Price
OrderDetail.Status = orders[i].Status
OrderDetail.Status = order.Status(orders[i].Status)
OrderDetail.CurrencyPair = currency.NewPairWithDelimiter(orders[i].Instrument,
orders[i].Currency,
b.GetPairFormat(asset.Spot, false).Delimiter)
@@ -488,7 +485,11 @@ func (b *BTCMarkets) WithdrawFiatFunds(withdrawRequest *exchange.FiatWithdrawReq
if withdrawRequest.Currency != currency.AUD {
return "", errors.New("only AUD is supported for withdrawals")
}
return b.WithdrawAUD(withdrawRequest.BankAccountName, fmt.Sprintf("%v", withdrawRequest.BankAccountNumber), withdrawRequest.BankName, fmt.Sprintf("%v", withdrawRequest.BankCode), withdrawRequest.Amount)
return b.WithdrawAUD(withdrawRequest.BankAccountName,
strconv.FormatFloat(withdrawRequest.BankAccountNumber, 'f', -1, 64),
withdrawRequest.BankName,
strconv.FormatFloat(withdrawRequest.BankCode, 'f', -1, 64),
withdrawRequest.Amount)
}
// WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a
@@ -512,24 +513,24 @@ func (b *BTCMarkets) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, err
}
// GetActiveOrders retrieves any orders that are active/open
func (b *BTCMarkets) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
func (b *BTCMarkets) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail, error) {
resp, err := b.GetOpenOrders()
if err != nil {
return nil, err
}
var orders []exchange.OrderDetail
var orders []order.Detail
for i := range resp {
var side exchange.OrderSide
if strings.EqualFold(resp[i].OrderSide, exchange.AskOrderSide.ToString()) {
side = exchange.SellOrderSide
} else if strings.EqualFold(resp[i].OrderSide, exchange.BidOrderSide.ToString()) {
side = exchange.BuyOrderSide
var side order.Side
if strings.EqualFold(resp[i].OrderSide, order.Ask.String()) {
side = order.Sell
} else if strings.EqualFold(resp[i].OrderSide, order.Bid.String()) {
side = order.Buy
}
orderDate := time.Unix(int64(resp[i].CreationTime), 0)
orderType := exchange.OrderType(strings.ToUpper(resp[i].OrderType))
orderType := order.Type(strings.ToUpper(resp[i].OrderType))
openOrder := exchange.OrderDetail{
openOrder := order.Detail{
ID: strconv.FormatInt(resp[i].ID, 10),
Amount: resp[i].Volume,
Exchange: b.Name,
@@ -538,7 +539,7 @@ func (b *BTCMarkets) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest
OrderSide: side,
OrderType: orderType,
Price: resp[i].Price,
Status: resp[i].Status,
Status: order.Status(resp[i].Status),
CurrencyPair: currency.NewPairWithDelimiter(resp[i].Instrument,
resp[i].Currency,
b.GetPairFormat(asset.Spot, false).Delimiter),
@@ -546,7 +547,7 @@ func (b *BTCMarkets) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest
for j := range resp[i].Trades {
tradeDate := time.Unix(int64(resp[i].Trades[j].CreationTime), 0)
openOrder.Trades = append(openOrder.Trades, exchange.TradeHistory{
openOrder.Trades = append(openOrder.Trades, order.TradeHistory{
Amount: resp[i].Trades[j].Volume,
Exchange: b.Name,
Price: resp[i].Trades[j].Price,
@@ -560,24 +561,23 @@ func (b *BTCMarkets) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest
orders = append(orders, openOrder)
}
exchange.FilterOrdersByType(&orders, getOrdersRequest.OrderType)
exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks,
getOrdersRequest.EndTicks)
exchange.FilterOrdersBySide(&orders, getOrdersRequest.OrderSide)
order.FilterOrdersByType(&orders, req.OrderType)
order.FilterOrdersByTickRange(&orders, req.StartTicks, req.EndTicks)
order.FilterOrdersBySide(&orders, req.OrderSide)
return orders, nil
}
// GetOrderHistory retrieves account order information
// Can Limit response to specific order status
func (b *BTCMarkets) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
if len(getOrdersRequest.Currencies) == 0 {
func (b *BTCMarkets) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail, error) {
if len(req.Currencies) == 0 {
return nil, errors.New("requires at least one currency pair to retrieve history")
}
var respOrders []Order
for _, currency := range getOrdersRequest.Currencies {
resp, err := b.GetOrders(currency.Base.String(),
currency.Quote.String(),
for i := range req.Currencies {
resp, err := b.GetOrders(req.Currencies[i].Base.String(),
req.Currencies[i].Quote.String(),
200,
0,
true)
@@ -587,18 +587,18 @@ func (b *BTCMarkets) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest
respOrders = append(respOrders, resp...)
}
var orders []exchange.OrderDetail
var orders []order.Detail
for i := range respOrders {
var side exchange.OrderSide
if strings.EqualFold(respOrders[i].OrderSide, exchange.AskOrderSide.ToString()) {
side = exchange.SellOrderSide
} else if strings.EqualFold(respOrders[i].OrderSide, exchange.BidOrderSide.ToString()) {
side = exchange.BuyOrderSide
var side order.Side
if strings.EqualFold(respOrders[i].OrderSide, order.Ask.String()) {
side = order.Sell
} else if strings.EqualFold(respOrders[i].OrderSide, order.Bid.String()) {
side = order.Buy
}
orderDate := time.Unix(int64(respOrders[i].CreationTime), 0)
orderType := exchange.OrderType(strings.ToUpper(respOrders[i].OrderType))
orderType := order.Type(strings.ToUpper(respOrders[i].OrderType))
openOrder := exchange.OrderDetail{
openOrder := order.Detail{
ID: strconv.FormatInt(respOrders[i].ID, 10),
Amount: respOrders[i].Volume,
Exchange: b.Name,
@@ -607,7 +607,7 @@ func (b *BTCMarkets) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest
OrderSide: side,
OrderType: orderType,
Price: respOrders[i].Price,
Status: respOrders[i].Status,
Status: order.Status(respOrders[i].Status),
CurrencyPair: currency.NewPairWithDelimiter(respOrders[i].Instrument,
respOrders[i].Currency,
b.GetPairFormat(asset.Spot, false).Delimiter),
@@ -615,7 +615,7 @@ func (b *BTCMarkets) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest
for j := range respOrders[i].Trades {
tradeDate := time.Unix(int64(respOrders[i].Trades[j].CreationTime), 0)
openOrder.Trades = append(openOrder.Trades, exchange.TradeHistory{
openOrder.Trades = append(openOrder.Trades, order.TradeHistory{
Amount: respOrders[i].Trades[j].Volume,
Exchange: b.Name,
Price: respOrders[i].Trades[j].Price,
@@ -628,9 +628,9 @@ func (b *BTCMarkets) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest
orders = append(orders, openOrder)
}
exchange.FilterOrdersByType(&orders, getOrdersRequest.OrderType)
exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks, getOrdersRequest.EndTicks)
exchange.FilterOrdersBySide(&orders, getOrdersRequest.OrderSide)
order.FilterOrdersByType(&orders, req.OrderType)
order.FilterOrdersByTickRange(&orders, req.StartTicks, req.EndTicks)
order.FilterOrdersBySide(&orders, req.OrderSide)
return orders, nil
}