Engine QA - Order update (#372)

Engine QA - Order update

exchanges/hitbtc/hitbtc_test.go

@@ -11,6 +11,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/sharedtestvalues"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/websocket/wshandler"
 )
@@ -232,8 +233,8 @@ func TestGetActiveOrders(t *testing.T) {
 	h.SetDefaults()
 	TestSetup(t)
 
-	var getOrdersRequest = exchange.GetOrdersRequest{
-		OrderType:  exchange.AnyOrderType,
+	var getOrdersRequest = order.GetOrdersRequest{
+		OrderType:  order.AnyType,
 		Currencies: []currency.Pair{currency.NewPair(currency.ETH, currency.BTC)},
 	}
 
@@ -249,8 +250,8 @@ func TestGetOrderHistory(t *testing.T) {
 	h.SetDefaults()
 	TestSetup(t)
 
-	var getOrdersRequest = exchange.GetOrdersRequest{
-		OrderType:  exchange.AnyOrderType,
+	var getOrdersRequest = order.GetOrdersRequest{
+		OrderType:  order.AnyType,
 		Currencies: []currency.Pair{currency.NewPair(currency.ETH, currency.BTC)},
 	}
 
@@ -276,13 +277,13 @@ 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{
 			Base:  currency.DGD,
 			Quote: currency.BTC,
 		},
-		OrderSide: exchange.BuyOrderSide,
-		OrderType: exchange.LimitOrderType,
+		OrderSide: order.Buy,
+		OrderType: order.Limit,
 		Price:     1,
 		Amount:    1,
 		ClientID:  "meowOrder",
@@ -305,7 +306,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",
@@ -331,7 +332,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",
@@ -347,13 +348,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 := h.ModifyOrder(&exchange.ModifyOrder{})
+	_, err := h.ModifyOrder(&order.Modify{})
 	if err == nil {
 		t.Error("ModifyOrder() Expected error")
 	}
@@ -480,7 +481,10 @@ func TestWsPlaceOrder(t *testing.T) {
 	if !canManipulateRealOrders {
 		t.Skip("canManipulateRealOrders false, skipping test")
 	}
-	_, err := h.wsPlaceOrder(currency.NewPair(currency.LTC, currency.BTC), exchange.BuyOrderSide.ToString(), 1, 1)
+	_, err := h.wsPlaceOrder(currency.NewPair(currency.LTC, currency.BTC),
+		order.Buy.String(),
+		1,
+		1)
 	if err != nil {
 		t.Fatal(err)
 	}

exchanges/hitbtc/hitbtc_wrapper.go

@@ -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,17 +341,18 @@ func (h *HitBTC) GetAccountInfo() (exchange.AccountInfo, error) {
 	}
 
 	var currencies []exchange.AccountCurrencyInfo
-	for _, item := range accountBalance {
+	for i := range accountBalance {
 		var exchangeCurrency exchange.AccountCurrencyInfo
-		exchangeCurrency.CurrencyName = currency.NewCode(item.Currency)
-		exchangeCurrency.TotalValue = item.Available
-		exchangeCurrency.Hold = item.Reserved
+		exchangeCurrency.CurrencyName = currency.NewCode(accountBalance[i].Currency)
+		exchangeCurrency.TotalValue = accountBalance[i].Available
+		exchangeCurrency.Hold = accountBalance[i].Reserved
 		currencies = append(currencies, exchangeCurrency)
 	}
 
-	response.Accounts = append(response.Accounts, exchange.Account{
-		Currencies: currencies,
-	})
+	response.Accounts = append(response.Accounts,
+		exchange.Account{
+			Currencies: currencies,
+		})
 
 	return response, nil
 }
@@ -368,23 +370,19 @@ func (h *HitBTC) GetExchangeHistory(p currency.Pair, assetType asset.Item) ([]ex
 }
 
 // SubmitOrder submits a new order
-func (h *HitBTC) 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 (h *HitBTC) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
+	var submitOrderResponse order.SubmitResponse
+	if err := s.Validate(); err != nil {
 		return submitOrderResponse, err
 	}
 
-	response, err := h.PlaceOrder(order.Pair.String(),
-		order.Price,
-		order.Amount,
-		strings.ToLower(order.OrderType.ToString()),
-		strings.ToLower(order.OrderSide.ToString()))
+	response, err := h.PlaceOrder(s.Pair.String(),
+		s.Price,
+		s.Amount,
+		strings.ToLower(s.OrderType.String()),
+		strings.ToLower(s.OrderSide.String()))
 	if response.OrderNumber > 0 {
-		submitOrderResponse.OrderID = fmt.Sprintf("%v", response.OrderNumber)
+		submitOrderResponse.OrderID = strconv.FormatInt(response.OrderNumber, 10)
 	}
 	if err == nil {
 		submitOrderResponse.IsOrderPlaced = true
@@ -394,27 +392,25 @@ func (h *HitBTC) SubmitOrder(order *exchange.OrderSubmission) (exchange.SubmitOr
 
 // ModifyOrder will allow of changing orderbook placement and limit to
 // market conversion
-func (h *HitBTC) ModifyOrder(action *exchange.ModifyOrder) (string, error) {
+func (h *HitBTC) ModifyOrder(action *order.Modify) (string, error) {
 	return "", common.ErrFunctionNotSupported
 }
 
 // CancelOrder cancels an order by its corresponding ID number
-func (h *HitBTC) CancelOrder(order *exchange.OrderCancellation) error {
+func (h *HitBTC) CancelOrder(order *order.Cancel) error {
 	orderIDInt, err := strconv.ParseInt(order.OrderID, 10, 64)
-
 	if err != nil {
 		return err
 	}
 
 	_, err = h.CancelExistingOrder(orderIDInt)
-
 	return err
 }
 
 // CancelAllOrders cancels all orders associated with a currency pair
-func (h *HitBTC) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.CancelAllOrdersResponse, error) {
-	cancelAllOrdersResponse := exchange.CancelAllOrdersResponse{
-		OrderStatus: make(map[string]string),
+func (h *HitBTC) CancelAllOrders(_ *order.Cancel) (order.CancelAllResponse, error) {
+	cancelAllOrdersResponse := order.CancelAllResponse{
+		Status: make(map[string]string),
 	}
 
 	resp, err := h.CancelAllExistingOrders()
@@ -424,7 +420,7 @@ func (h *HitBTC) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Cancel
 
 	for i := range resp {
 		if resp[i].Status != "canceled" {
-			cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(resp[i].ID, 10)] =
+			cancelAllOrdersResponse.Status[strconv.FormatInt(resp[i].ID, 10)] =
 				fmt.Sprintf("Could not cancel order %v. Status: %v",
 					resp[i].ID,
 					resp[i].Status)
@@ -435,8 +431,8 @@ func (h *HitBTC) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.Cancel
 }
 
 // GetOrderInfo returns information on a current open order
-func (h *HitBTC) GetOrderInfo(orderID string) (exchange.OrderDetail, error) {
-	var orderDetail exchange.OrderDetail
+func (h *HitBTC) GetOrderInfo(orderID string) (order.Detail, error) {
+	var orderDetail order.Detail
 	return orderDetail, common.ErrNotYetImplemented
 }
 
@@ -454,7 +450,6 @@ func (h *HitBTC) GetDepositAddress(currency currency.Code, _ string) (string, er
 // submitted
 func (h *HitBTC) WithdrawCryptocurrencyFunds(withdrawRequest *exchange.CryptoWithdrawRequest) (string, error) {
 	_, err := h.Withdraw(withdrawRequest.Currency.String(), withdrawRequest.Address, withdrawRequest.Amount)
-
 	return "", err
 }
 
@@ -485,26 +480,26 @@ func (h *HitBTC) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, error)
 }
 
 // GetActiveOrders retrieves any orders that are active/open
-func (h *HitBTC) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
-	if len(getOrdersRequest.Currencies) == 0 {
+func (h *HitBTC) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail, error) {
+	if len(req.Currencies) == 0 {
 		return nil, errors.New("currency must be supplied")
 	}
 
 	var allOrders []OrderHistoryResponse
-	for _, currency := range getOrdersRequest.Currencies {
-		resp, err := h.GetOpenOrders(currency.String())
+	for i := range req.Currencies {
+		resp, err := h.GetOpenOrders(req.Currencies[i].String())
 		if err != nil {
 			return nil, err
 		}
 		allOrders = append(allOrders, resp...)
 	}
 
-	var orders []exchange.OrderDetail
+	var orders []order.Detail
 	for i := range allOrders {
 		symbol := currency.NewPairDelimiter(allOrders[i].Symbol,
 			h.GetPairFormat(asset.Spot, false).Delimiter)
-		side := exchange.OrderSide(strings.ToUpper(allOrders[i].Side))
-		orders = append(orders, exchange.OrderDetail{
+		side := order.Side(strings.ToUpper(allOrders[i].Side))
+		orders = append(orders, order.Detail{
 			ID:           allOrders[i].ID,
 			Amount:       allOrders[i].Quantity,
 			Exchange:     h.Name,
@@ -515,34 +510,33 @@ func (h *HitBTC) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([
 		})
 	}
 
-	exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks,
-		getOrdersRequest.EndTicks)
-	exchange.FilterOrdersBySide(&orders, getOrdersRequest.OrderSide)
+	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 (h *HitBTC) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
-	if len(getOrdersRequest.Currencies) == 0 {
+func (h *HitBTC) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail, error) {
+	if len(req.Currencies) == 0 {
 		return nil, errors.New("currency must be supplied")
 	}
 
 	var allOrders []OrderHistoryResponse
-	for _, currency := range getOrdersRequest.Currencies {
-		resp, err := h.GetOrders(currency.String())
+	for i := range req.Currencies {
+		resp, err := h.GetOrders(req.Currencies[i].String())
 		if err != nil {
 			return nil, err
 		}
 		allOrders = append(allOrders, resp...)
 	}
 
-	var orders []exchange.OrderDetail
+	var orders []order.Detail
 	for i := range allOrders {
 		symbol := currency.NewPairDelimiter(allOrders[i].Symbol,
 			h.GetPairFormat(asset.Spot, false).Delimiter)
-		side := exchange.OrderSide(strings.ToUpper(allOrders[i].Side))
-		orders = append(orders, exchange.OrderDetail{
+		side := order.Side(strings.ToUpper(allOrders[i].Side))
+		orders = append(orders, order.Detail{
 			ID:           allOrders[i].ID,
 			Amount:       allOrders[i].Quantity,
 			Exchange:     h.Name,
@@ -553,8 +547,8 @@ func (h *HitBTC) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([
 		})
 	}
 
-	exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks, getOrdersRequest.EndTicks)
-	exchange.FilterOrdersBySide(&orders, getOrdersRequest.OrderSide)
+	order.FilterOrdersByTickRange(&orders, req.StartTicks, req.EndTicks)
+	order.FilterOrdersBySide(&orders, req.OrderSide)
 	return orders, nil
 }