sentio/util/order.go

package util

import (
	"errors"
	"git.beejay.kim/Gshopper/sentio"
	"math"
)

func CreateOrder(
	m sentio.Market,
	s sentio.Strategy,
	t sentio.Side,
	stamp *sentio.Probability_Stamp,
	quotes map[string]sentio.Quote,
	rm sentio.RiskManager,
) error {
	var (
		symbol    string
		account   sentio.MarketAccount
		threshold float32
		size      uint
		bid       float64
		tp        float64
		sl        float64
		ok        bool
		err       error
	)

	if symbol, ok = s.PositionSymbols()[t]; !ok {
		return errors.New("`CreateOrder`: unknown Side for the current strategy")
	}

	if !rm.EnsureVolatility(symbol) {
		return sentio.ErrLowVolatility
	}

	bid = sentio.ToFixed(quotes[symbol].BidPrice, 2)
	tp = sentio.ToFixed(rm.TakeProfit(symbol, bid), 2)
	sl = sentio.ToFixed(rm.StopLoss(symbol, bid), 2)

	// define threshold
	if threshold, ok = s.PositionProbabilities()[t]; !ok {
		return nil
	}

	// Prevent orders those have too small expected profit
	if tp < bid+0.02 {
		return sentio.ErrLowTakeProfit
	}

	// Prevent cases when order will be closed ASAP they were opened.
	// Also, Alpaca requires at least 0.01 gap against base_price
	if sl > bid-0.01 {
		return sentio.ErrHighStoploss
	}

	if account, err = m.Account(); err != nil {
		return err
	}

	if account.GetCash() < bid {
		return sentio.ErrTooSmallOrder
	}

	if sentio.LONG == t && stamp.Value > threshold ||
		sentio.SHORT == t && stamp.Value < threshold {

		// create a new order
		if size = uint(math.Floor(account.GetCash() * .9 / bid)); size < 1 {
			return sentio.ErrTooSmallOrder
		}

		_, err = m.CreateOrder(symbol, size, rm)
		return err
	}

	return nil
}

func CloseAllOrders(m sentio.Market, s sentio.Strategy) error {
	var (
		symbols = Symbols(s)
		orders  []sentio.Order
		err     error
	)

	if orders, err = m.Orders(sentio.OrderListCriteria{
		Status:  "open",
		Symbols: symbols,
	}); err != nil {
		return err
	}

	for i := range orders {
		if _, err = m.CloseOrder(orders[i]); err != nil {
			return err
		}
	}

	return nil
}