Ejemplo n.º 1
0
        private OpenCloseInfo GetOpenCloseInfo()
        {
            var info = new OpenCloseInfo();
            var p    = Manager.GetPosition(Order.Instrument);

            var(closeQty, closeTodayQty) = GetCloseItems();

            var oc = Order.GetOpenClose(true);

            switch (oc)
            {
            case OpenCloseType.Undefined:
                AutoOpenClose(false);
                break;

            case OpenCloseType.Open:
                info.Open = Order.Qty;
                break;

            case OpenCloseType.Close:
                AutoOpenClose();
                break;

            case OpenCloseType.CloseToday:
                info.CloseToday = Math.Min(Order.Qty, closeTodayQty);
                break;

            default:
                break;
            }
            return(info);

            #region local
            (double, double) GetCloseItems()
            {
                double close, closeToday;

                if (Order.Side == OrderSide.Buy)
                {
                    (closeToday, close) = p.Short.GetCanCloseQty();
                }
                else
                {
                    (closeToday, close) = p.Long.GetCanCloseQty();
                }
                if (!_rules.CloseToday)
                {
                    close     += closeToday;
                    closeToday = 0;
                }
                return(close, closeToday);
            }

            void AutoOpenClose(bool closeOnly = true)
            {
                var qty = Order.Qty;

                if (_rules.CloseToday)
                {
                    if (_rules.CloseTodayFirst)
                    {
                        info.CloseToday = Math.Min(qty, closeTodayQty);
                        qty            -= closeTodayQty;
                        if (qty <= 0)
                        {
                            return;
                        }
                    }
                    info.Close = Math.Min(qty, closeQty);
                    qty       -= closeQty;
                    if (qty <= 0)
                    {
                        return;
                    }
                    if (!_rules.CloseTodayFirst)
                    {
                        info.CloseToday = Math.Min(qty, closeTodayQty);
                        qty            -= closeTodayQty;
                        if (qty <= 0)
                        {
                            return;
                        }
                    }
                }
                else
                {
                    info.Close = Math.Min(qty, closeQty);
                    qty       -= closeQty;
                    if (qty <= 0)
                    {
                        return;
                    }
                }
                if (!closeOnly)
                {
                    info.Open = qty;
                }
            }

            #endregion
        }
        private OpenCloseInfo GetOpenCloseInfo()
        {
            var info = new OpenCloseInfo();

            (double closeQty, double closeTodayQty) = GetCloseQty();

            var openCloseType = _order.GetOpenClose(true);

            switch (openCloseType)
            {
            case OpenCloseType.Undefined:
                AutoOpenClose(false);
                break;

            case OpenCloseType.Open:
                info.Open = _order.Qty;
                break;

            case OpenCloseType.Close:
                AutoOpenClose();
                break;

            case OpenCloseType.CloseToday:
                if (_rules.StrictCloseToday)
                {
                    info.CloseToday = Math.Min(_order.Qty, closeTodayQty);
                }
                else
                {
                    AutoOpenClose();
                }
                break;

            case OpenCloseType.LockToday:
                if (closeTodayQty > 0)
                {
                    info.Open = _order.Qty;
                }
                else
                {
                    info.Close = Math.Min(_order.Qty, closeQty);
                    info.Open  = Math.Max(0, _order.Qty - closeQty);
                }
                break;
            }
            return(info);

            #region local
            (double close, double closeToday) GetCloseQty()
            {
                double closeToday, close;

                (closeToday, close) = _order.Side == OrderSide.Buy
                    ? _position.Short.GetCanCloseQty()
                    : _position.Long.GetCanCloseQty();

                if (!_rules.DisableCloseToday)
                {
                    return(close, closeToday);
                }

                close     -= closeToday;
                closeToday = 0;
                return(close, closeToday);
            }

            void AutoOpenClose(bool closeOnly = true)
            {
                var qty = _order.Qty;

                if (_rules.StrictCloseToday)
                {
                    closeQty       -= closeTodayQty;
                    info.CloseToday = Math.Min(qty, closeTodayQty);
                    qty            -= info.CloseToday;
                    if (Math.Abs(qty) < double.Epsilon)
                    {
                        return;
                    }
                }

                info.Close = Math.Min(qty, closeQty);
                qty       -= info.Close;
                if (Math.Abs(qty) < double.Epsilon)
                {
                    return;
                }
                if (!closeOnly)
                {
                    info.Open = qty;
                }
            }

            #endregion
        }