d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-06-07 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

130
exchanges/zb/zb_wrapper.go
View File

@@ -12,6 +12,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"
@@ -344,27 +345,23 @@ func (z *ZB) GetExchangeHistory(p currency.Pair, assetType asset.Item) ([]exchan
}
// SubmitOrder submits a new order
func (z *ZB) 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 (z *ZB) SubmitOrder(s *order.Submit) (order.SubmitResponse, error) {
var submitOrderResponse order.SubmitResponse
if err := s.Validate(); err != nil {
return submitOrderResponse, err
}
var oT SpotNewOrderRequestParamsType
if order.OrderSide == exchange.BuyOrderSide {
if s.OrderSide == order.Buy {
oT = SpotNewOrderRequestParamsTypeBuy
} else {
oT = SpotNewOrderRequestParamsTypeSell
}
var params = SpotNewOrderRequestParams{
Amount: order.Amount,
Price: order.Price,
Symbol: order.Pair.Lower().String(),
Amount: s.Amount,
Price: s.Price,
Symbol: s.Pair.Lower().String(),
Type: oT,
}
response, err := z.SpotNewOrder(params)
@@ -379,32 +376,34 @@ func (z *ZB) SubmitOrder(order *exchange.OrderSubmission) (exchange.SubmitOrderR
// ModifyOrder will allow of changing orderbook placement and limit to
// market conversion
func (z *ZB) ModifyOrder(action *exchange.ModifyOrder) (string, error) {
func (z *ZB) ModifyOrder(action *order.Modify) (string, error) {
return "", common.ErrFunctionNotSupported
}
// CancelOrder cancels an order by its corresponding ID number
func (z *ZB) CancelOrder(order *exchange.OrderCancellation) error {
orderIDInt, err := strconv.ParseInt(order.OrderID, 10, 64)
func (z *ZB) CancelOrder(o *order.Cancel) error {
orderIDInt, err := strconv.ParseInt(o.OrderID, 10, 64)
if err != nil {
return err
}
return z.CancelExistingOrder(orderIDInt, z.FormatExchangeCurrency(order.CurrencyPair,
order.AssetType).String())
curr := z.FormatExchangeCurrency(o.CurrencyPair, o.AssetType).String()
return z.CancelExistingOrder(orderIDInt, curr)
}
// CancelAllOrders cancels all orders associated with a currency pair
func (z *ZB) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.CancelAllOrdersResponse, error) {
cancelAllOrdersResponse := exchange.CancelAllOrdersResponse{
OrderStatus: make(map[string]string),
func (z *ZB) CancelAllOrders(_ *order.Cancel) (order.CancelAllResponse, error) {
cancelAllOrdersResponse := order.CancelAllResponse{
Status: make(map[string]string),
}
var allOpenOrders []Order
for _, currency := range z.GetEnabledPairs(asset.Spot) {
enabledPairs := z.GetEnabledPairs(asset.Spot)
for x := range enabledPairs {
// Limiting to 10 pages
for i := 0; i < 10; i++ {
openOrders, err := z.GetUnfinishedOrdersIgnoreTradeType(z.FormatExchangeCurrency(currency, asset.Spot).String(), 1, 10)
for pageNumber := int64(0); pageNumber < 11; pageNumber++ {
fCurr := z.FormatExchangeCurrency(enabledPairs[x], asset.Spot).String()
openOrders, err := z.GetUnfinishedOrdersIgnoreTradeType(fCurr,
pageNumber,
10)
if err != nil {
return cancelAllOrdersResponse, err
}
@@ -417,10 +416,12 @@ func (z *ZB) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.CancelAllO
}
}
for _, openOrder := range allOpenOrders {
err := z.CancelExistingOrder(openOrder.ID, openOrder.Currency)
for i := range allOpenOrders {
err := z.CancelExistingOrder(allOpenOrders[i].ID,
allOpenOrders[i].Currency)
if err != nil {
cancelAllOrdersResponse.OrderStatus[strconv.FormatInt(openOrder.ID, 10)] = err.Error()
ID := strconv.FormatInt(allOpenOrders[i].ID, 10)
cancelAllOrdersResponse.Status[ID] = err.Error()
}
}
@@ -428,8 +429,8 @@ func (z *ZB) CancelAllOrders(_ *exchange.OrderCancellation) (exchange.CancelAllO
}
// GetOrderInfo returns information on a current open order
func (z *ZB) GetOrderInfo(orderID string) (exchange.OrderDetail, error) {
var orderDetail exchange.OrderDetail
func (z *ZB) GetOrderInfo(orderID string) (order.Detail, error) {
var orderDetail order.Detail
return orderDetail, common.ErrNotYetImplemented
}
@@ -477,13 +478,15 @@ func (z *ZB) GetFeeByType(feeBuilder *exchange.FeeBuilder) (float64, error) {
// GetActiveOrders retrieves any orders that are active/open
// This function is not concurrency safe due to orderSide/orderType maps
func (z *ZB) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
func (z *ZB) GetActiveOrders(req *order.GetOrdersRequest) ([]order.Detail, error) {
var allOrders []Order
for _, currency := range getOrdersRequest.Currencies {
var pageNumber int64
for x := range req.Currencies {
// Limiting to 10 pages
for i := 0; i < 10; i++ {
resp, err := z.GetUnfinishedOrdersIgnoreTradeType(z.FormatExchangeCurrency(currency, asset.Spot).String(), pageNumber, 10)
for pageNumber := int64(0); pageNumber < 11; pageNumber++ {
fCurr := z.FormatExchangeCurrency(req.Currencies[x], asset.Spot).String()
resp, err := z.GetUnfinishedOrdersIgnoreTradeType(fCurr,
pageNumber,
10)
if err != nil {
return nil, err
}
@@ -492,53 +495,51 @@ func (z *ZB) GetActiveOrders(getOrdersRequest *exchange.GetOrdersRequest) ([]exc
}
allOrders = append(allOrders, resp...)
pageNumber++
}
}
var orders []exchange.OrderDetail
for _, order := range allOrders {
symbol := currency.NewPairDelimiter(order.Currency,
var orders []order.Detail
for i := range allOrders {
symbol := currency.NewPairDelimiter(allOrders[i].Currency,
z.GetPairFormat(asset.Spot, false).Delimiter)
orderDate := time.Unix(int64(order.TradeDate), 0)
orderSide := orderSideMap[order.Type]
orders = append(orders, exchange.OrderDetail{
ID: fmt.Sprintf("%v", order.ID),
Amount: order.TotalAmount,
orderDate := time.Unix(int64(allOrders[i].TradeDate), 0)
orderSide := orderSideMap[allOrders[i].Type]
orders = append(orders, order.Detail{
ID: fmt.Sprintf("%d", allOrders[i].ID),
Amount: allOrders[i].TotalAmount,
Exchange: z.Name,
OrderDate: orderDate,
Price: order.Price,
Price: allOrders[i].Price,
OrderSide: orderSide,
CurrencyPair: symbol,
})
}
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
// This function is not concurrency safe due to orderSide/orderType maps
func (z *ZB) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([]exchange.OrderDetail, error) {
if getOrdersRequest.OrderSide == exchange.AnyOrderSide || getOrdersRequest.OrderSide == "" {
func (z *ZB) GetOrderHistory(req *order.GetOrdersRequest) ([]order.Detail, error) {
if req.OrderSide == order.AnySide || req.OrderSide == "" {
return nil, errors.New("specific order side is required")
}
var allOrders []Order
var side int64
if getOrdersRequest.OrderSide == exchange.BuyOrderSide {
if req.OrderSide == order.Buy {
side = 1
}
for _, currency := range getOrdersRequest.Currencies {
var pageNumber int64
for x := range req.Currencies {
// Limiting to 10 pages
for i := 0; i < 10; i++ {
resp, err := z.GetOrders(z.FormatExchangeCurrency(currency, asset.Spot).String(), pageNumber, side)
for pageNumber := int64(0); pageNumber < 11; pageNumber++ {
fCurr := z.FormatExchangeCurrency(req.Currencies[x], asset.Spot).String()
resp, err := z.GetOrders(fCurr, pageNumber, side)
if err != nil {
return nil, err
}
@@ -548,28 +549,27 @@ func (z *ZB) GetOrderHistory(getOrdersRequest *exchange.GetOrdersRequest) ([]exc
}
allOrders = append(allOrders, resp...)
pageNumber++
}
}
var orders []exchange.OrderDetail
for _, order := range allOrders {
symbol := currency.NewPairDelimiter(order.Currency,
var orders []order.Detail
for i := range allOrders {
symbol := currency.NewPairDelimiter(allOrders[i].Currency,
z.GetPairFormat(asset.Spot, false).Delimiter)
orderDate := time.Unix(int64(order.TradeDate), 0)
orderSide := orderSideMap[order.Type]
orders = append(orders, exchange.OrderDetail{
ID: fmt.Sprintf("%v", order.ID),
Amount: order.TotalAmount,
orderDate := time.Unix(int64(allOrders[i].TradeDate), 0)
orderSide := orderSideMap[allOrders[i].Type]
orders = append(orders, order.Detail{
ID: fmt.Sprintf("%d", allOrders[i].ID),
Amount: allOrders[i].TotalAmount,
Exchange: z.Name,
OrderDate: orderDate,
Price: order.Price,
Price: allOrders[i].Price,
OrderSide: orderSide,
CurrencyPair: symbol,
})
}
exchange.FilterOrdersByTickRange(&orders, getOrdersRequest.StartTicks, getOrdersRequest.EndTicks)
order.FilterOrdersByTickRange(&orders, req.StartTicks, req.EndTicks)
return orders, nil
}