示例#1
0
            protected override bool?OnProcess(FixSession session, string msgType, IFixReader reader)
            {
                switch (msgType)
                {
                case QuikFixMessages.NewStopOrderSingle:
                {
                    var condition = new QuikOrderCondition();

                    var dto = TimeHelper.Moscow.BaseUtcOffset;

                    var regMsg = reader.ReadOrderRegisterMessage(dto,
                                                                 tag => reader.ReadOrderCondition(tag, dto, condition));

                    if (regMsg == null)
                    {
                        return(null);
                    }

                    regMsg.TransactionId = CreateTransactionId(session, regMsg.TransactionId.To <string>());
                    regMsg.Condition     = condition;

                    RaiseNewOutMessage(regMsg);
                    return(true);
                }
                }

                return(base.OnProcess(session, msgType, reader));
            }
        /// <summary>
        /// Метод вызывается при обработке полученного сообщения.
        /// </summary>
        /// <param name="msgType">Тип FIX сообщения.</param>
        /// <param name="reader">Читатель данных, записанных в формате FIX протокола.</param>
        /// <returns>Успешно ли обработаны данные.</returns>
        protected override bool?ProcessTransactionMessage(string msgType, IFixReader reader)
        {
            switch (msgType)
            {
            case QuikFixMessages.StopOrderExecutionReport:
            {
                var condition = new QuikOrderCondition();

                var executions = reader.ReadExecutionMessage(this,
                                                             tag => reader.ReadOrderCondition(tag, UtcOffset, condition));

                if (executions == null)
                {
                    return(null);
                }

                var exec = executions.First();
                exec.Condition = condition;

                SendOutMessage(exec);

                return(true);
            }
            }

            return(base.ProcessTransactionMessage(msgType, reader));
        }
示例#3
0
            protected override void OnProcess(FixSession session, string client, string msgStr, bool isMarketData)
            {
                var msgType = QuickFix.Message.GetMsgType(msgStr);

                switch (msgType)
                {
                case QuikFixMessages.NewStopOrderSingle:
                {
                    this.AddInfoLog("From client {0}: NewStopOrderSingle", client);

                    var fixMsg = session.ToMessage <NewStopOrderSingle>(msgStr);
                    var regMsg = fixMsg.ToRegisterMessage();

                    regMsg.TransactionId = CreateTransactionId(client, regMsg.TransactionId);

                    var condition = new QuikOrderCondition
                    {
                        Type                            = (QuikOrderConditionTypes)fixMsg.Type.Obj,
                        Result                          = fixMsg.IsSetResult() ? (QuikOrderConditionResults?)fixMsg.Result.Obj : null,
                        StopPriceCondition              = (QuikStopPriceConditions)fixMsg.StopPriceCondition.Obj,
                        StopPrice                       = fixMsg.IsSetStopPx() ? fixMsg.StopPx.Obj : (decimal?)null,
                        StopLimitPrice                  = fixMsg.IsSetStopLimitPrice() ? fixMsg.StopLimitPrice.Obj : (decimal?)null,
                        IsMarketStopLimit               = fixMsg.IsSetIsMarketStopLimit() ? fixMsg.IsMarketStopLimit.Obj : (bool?)null,
                        ConditionOrderId                = fixMsg.IsSetConditionOrderId() ? fixMsg.ConditionOrderId.Obj : (long?)null,
                        ConditionOrderSide              = (Sides)fixMsg.ConditionOrderSide.Obj,
                        ConditionOrderPartiallyMatched  = fixMsg.IsSetConditionOrderPartiallyMatched() ? fixMsg.ConditionOrderPartiallyMatched.Obj : (bool?)null,
                        ConditionOrderUseMatchedBalance = fixMsg.IsSetConditionOrderUseMatchedBalance() ? fixMsg.ConditionOrderUseMatchedBalance.Obj : (bool?)null,
                        LinkedOrderPrice                = fixMsg.IsSetLinkedOrderPrice() ? fixMsg.LinkedOrderPrice.Obj : (decimal?)null,
                        LinkedOrderCancel               = fixMsg.LinkedOrderCancel.Obj,
                        Offset                          = fixMsg.IsSetOffset() ? fixMsg.Offset.Obj.ToUnit() : null,
                        Spread                          = fixMsg.IsSetStopSpread() ? fixMsg.StopSpread.Obj.ToUnit() : null,
                        IsMarketTakeProfit              = fixMsg.IsSetIsMarketTakeProfit() ? fixMsg.IsMarketTakeProfit.Obj : (bool?)null,
                    };

                    if (fixMsg.IsSetOtherSecurityCode())
                    {
                        condition.OtherSecurityId = new SecurityId {
                            SecurityCode = fixMsg.OtherSecurityCode.Obj
                        }
                    }
                    ;
                    if (fixMsg.IsSetActiveTimeFrom() && fixMsg.IsSetActiveTimeTo())
                    {
                        condition.ActiveTime = new Range <DateTimeOffset>(fixMsg.ActiveTimeFrom.Obj.ApplyTimeZone(TimeHelper.Moscow), fixMsg.ActiveTimeTo.Obj.ApplyTimeZone(TimeHelper.Moscow));
                    }

                    regMsg.Condition = condition;

                    TransactionAdapter.SendInMessage(regMsg);
                    return;
                }
                }

                base.OnProcess(session, client, msgStr, isMarketData);
            }
示例#4
0
        public static void WriteOrderCondition(this IFixWriter writer, QuikOrderCondition condition, string dateTimeFormat)
        {
            if (writer == null)
            {
                throw new ArgumentNullException(nameof(writer));
            }

            if (condition == null)
            {
                throw new ArgumentNullException(nameof(condition));
            }

            if (condition.Type != null)
            {
                writer.Write((FixTags)QuikFixTags.Type);
                writer.Write((int)condition.Type.Value);
            }

            if (condition.StopPriceCondition != null)
            {
                writer.Write((FixTags)QuikFixTags.StopPriceCondition);
                writer.Write((int)condition.StopPriceCondition.Value);
            }

            if (condition.ConditionOrderSide != null)
            {
                writer.Write((FixTags)QuikFixTags.ConditionOrderSide);
                writer.Write((int)condition.ConditionOrderSide.Value);
            }

            if (condition.LinkedOrderCancel != null)
            {
                writer.Write((FixTags)QuikFixTags.LinkedOrderCancel);
                writer.Write(condition.LinkedOrderCancel.Value);
            }

            if (condition.Result != null)
            {
                writer.Write((FixTags)QuikFixTags.Result);
                writer.Write((int)condition.Result.Value);
            }

            if (condition.OtherSecurityId != null)
            {
                writer.Write((FixTags)QuikFixTags.OtherSecurityCode);
                writer.Write(condition.OtherSecurityId.Value.SecurityCode);
            }

            if (condition.StopPrice != null)
            {
                writer.Write((FixTags)QuikFixTags.StopPrice);
                writer.Write(condition.StopPrice.Value);
            }

            if (condition.StopLimitPrice != null)
            {
                writer.Write((FixTags)QuikFixTags.StopLimitPrice);
                writer.Write(condition.StopLimitPrice.Value);
            }

            if (condition.IsMarketStopLimit != null)
            {
                writer.Write((FixTags)QuikFixTags.IsMarketStopLimit);
                writer.Write(condition.IsMarketStopLimit.Value);
            }

            if (condition.ActiveTime != null)
            {
                writer.Write((FixTags)QuikFixTags.ActiveTimeFrom);
                writer.Write(condition.ActiveTime.Min.UtcDateTime, dateTimeFormat);

                writer.Write((FixTags)QuikFixTags.ActiveTimeTo);
                writer.Write(condition.ActiveTime.Max.UtcDateTime, dateTimeFormat);
            }

            if (condition.ConditionOrderId != null)
            {
                writer.Write((FixTags)QuikFixTags.ConditionOrderId);
                writer.Write(condition.ConditionOrderId.Value);
            }

            if (condition.ConditionOrderPartiallyMatched != null)
            {
                writer.Write((FixTags)QuikFixTags.ConditionOrderPartiallyMatched);
                writer.Write(condition.ConditionOrderPartiallyMatched.Value);
            }

            if (condition.ConditionOrderUseMatchedBalance != null)
            {
                writer.Write((FixTags)QuikFixTags.ConditionOrderUseMatchedBalance);
                writer.Write(condition.ConditionOrderUseMatchedBalance.Value);
            }

            if (condition.LinkedOrderPrice != null)
            {
                writer.Write((FixTags)QuikFixTags.LinkedOrderPrice);
                writer.Write(condition.LinkedOrderPrice.Value);
            }

            if (condition.Offset != null)
            {
                writer.Write((FixTags)QuikFixTags.Offset);
                writer.Write(condition.Offset.ToString());
            }

            if (condition.Spread != null)
            {
                writer.Write((FixTags)QuikFixTags.StopSpread);
                writer.Write(condition.Spread.ToString());
            }

            if (condition.IsMarketTakeProfit != null)
            {
                writer.Write((FixTags)QuikFixTags.IsMarketTakeProfit);
                writer.Write(condition.IsMarketTakeProfit.Value);
            }
        }
示例#5
0
		public static void WriteOrderCondition(this IFixWriter writer, QuikOrderCondition condition)
		{
			if (writer == null)
				throw new ArgumentNullException("writer");

			if (condition == null)
				throw new ArgumentNullException("condition");

			if (condition.Type != null)
			{
				writer.Write((FixTags)QuikFixTags.Type);
				writer.Write((int)condition.Type.Value);
			}

			if (condition.StopPriceCondition != null)
			{
				writer.Write((FixTags)QuikFixTags.StopPriceCondition);
				writer.Write((int)condition.StopPriceCondition.Value);
			}

			if (condition.ConditionOrderSide != null)
			{
				writer.Write((FixTags)QuikFixTags.ConditionOrderSide);
				writer.Write((int)condition.ConditionOrderSide.Value);
			}

			if (condition.LinkedOrderCancel != null)
			{
				writer.Write((FixTags)QuikFixTags.LinkedOrderCancel);
				writer.Write(condition.LinkedOrderCancel.Value);
			}

			if (condition.Result != null)
			{
				writer.Write((FixTags)QuikFixTags.Result);
				writer.Write((int)condition.Result.Value);
			}

			if (condition.OtherSecurityId != null)
			{
				writer.Write((FixTags)QuikFixTags.OtherSecurityCode);
				writer.Write(condition.OtherSecurityId.Value.SecurityCode);
			}

			if (condition.StopPrice != null)
			{
				writer.Write((FixTags)QuikFixTags.StopPrice);
				writer.Write(condition.StopPrice.Value);
			}

			if (condition.StopLimitPrice != null)
			{
				writer.Write((FixTags)QuikFixTags.StopLimitPrice);
				writer.Write(condition.StopLimitPrice.Value);
			}

			if (condition.IsMarketStopLimit != null)
			{
				writer.Write((FixTags)QuikFixTags.IsMarketStopLimit);
				writer.Write(condition.IsMarketStopLimit.Value);
			}

			if (condition.ActiveTime != null)
			{
				writer.Write((FixTags)QuikFixTags.ActiveTimeFrom);
				writer.Write(condition.ActiveTime.Min.UtcDateTime);

				writer.Write((FixTags)QuikFixTags.ActiveTimeTo);
				writer.Write(condition.ActiveTime.Max.UtcDateTime);
			}

			if (condition.ConditionOrderId != null)
			{
				writer.Write((FixTags)QuikFixTags.ConditionOrderId);
				writer.Write(condition.ConditionOrderId.Value);
			}

			if (condition.ConditionOrderPartiallyMatched != null)
			{
				writer.Write((FixTags)QuikFixTags.ConditionOrderPartiallyMatched);
				writer.Write(condition.ConditionOrderPartiallyMatched.Value);
			}

			if (condition.ConditionOrderUseMatchedBalance != null)
			{
				writer.Write((FixTags)QuikFixTags.ConditionOrderUseMatchedBalance);
				writer.Write(condition.ConditionOrderUseMatchedBalance.Value);
			}

			if (condition.LinkedOrderPrice != null)
			{
				writer.Write((FixTags)QuikFixTags.LinkedOrderPrice);
				writer.Write(condition.LinkedOrderPrice.Value);
			}

			if (condition.Offset != null)
			{
				writer.Write((FixTags)QuikFixTags.Offset);
				writer.Write(condition.Offset.ToString());
			}

			if (condition.Spread != null)
			{
				writer.Write((FixTags)QuikFixTags.StopSpread);
				writer.Write(condition.Spread.ToString());
			}

			if (condition.IsMarketTakeProfit != null)
			{
				writer.Write((FixTags)QuikFixTags.IsMarketTakeProfit);
				writer.Write(condition.IsMarketTakeProfit.Value);
			}
		}
        /// <summary>
        /// Метод вызывается при обработке полученного сообщения.
        /// </summary>
        /// <param name="msgType">Тип FIX сообщения.</param>
        /// <param name="reader">Читатель данных, записанных в формате FIX протокола.</param>
        /// <returns>Успешно ли обработаны данные.</returns>
        protected override bool?ProcessTransactionMessage(string msgType, FixReader reader)
        {
            switch (msgType)
            {
            case QuikFixMessages.StopOrderExecutionReport:
            {
                int?           type = null;
                int?           stopPriceCondition              = null;
                int?           conditionOrderSide              = null;
                bool?          linkedOrderCancel               = null;
                int?           result                          = null;
                string         otherSecurityCode               = null;
                decimal?       stopPrice                       = null;
                decimal?       stopLimitPrice                  = null;
                bool?          isMarketStopLimit               = null;
                DateTimeOffset?activeTimeFrom                  = null;
                DateTimeOffset?activeTimeTo                    = null;
                long?          conditionOrderId                = null;
                bool?          conditionOrderPartiallyMatched  = null;
                bool?          conditionOrderUseMatchedBalance = null;
                decimal?       linkedOrderPrice                = null;
                string         offset                          = null;
                string         stopSpread                      = null;
                bool?          isMarketTakeProfit              = null;

                var executions = reader.ReadExecutionMessage(Session, SessionHolder.UtcOffset, tag =>
                    {
                        switch ((QuikFixTags)tag)
                        {
                        case QuikFixTags.Type:
                            type = reader.ReadInt();
                            return(true);

                        case QuikFixTags.StopPriceCondition:
                            stopPriceCondition = reader.ReadInt();
                            return(true);

                        case QuikFixTags.ConditionOrderSide:
                            conditionOrderSide = reader.ReadInt();
                            return(true);

                        case QuikFixTags.LinkedOrderCancel:
                            linkedOrderCancel = reader.ReadBool();
                            return(true);

                        case QuikFixTags.Result:
                            result = reader.ReadInt();
                            return(true);

                        case QuikFixTags.OtherSecurityCode:
                            otherSecurityCode = reader.ReadString();
                            return(true);

                        case QuikFixTags.StopPrice:
                            stopPrice = reader.ReadDecimal();
                            return(true);

                        case QuikFixTags.StopLimitPrice:
                            stopLimitPrice = reader.ReadDecimal();
                            return(true);

                        case QuikFixTags.IsMarketStopLimit:
                            isMarketStopLimit = reader.ReadBool();
                            return(true);

                        case QuikFixTags.ActiveTimeFrom:
                            activeTimeFrom = reader.ReadDateTime().ApplyTimeZone(SessionHolder.UtcOffset);
                            return(true);

                        case QuikFixTags.ActiveTimeTo:
                            activeTimeTo = reader.ReadDateTime().ApplyTimeZone(SessionHolder.UtcOffset);
                            return(true);

                        case QuikFixTags.ConditionOrderId:
                            conditionOrderId = reader.ReadLong();
                            return(true);

                        case QuikFixTags.ConditionOrderPartiallyMatched:
                            conditionOrderPartiallyMatched = reader.ReadBool();
                            return(true);

                        case QuikFixTags.ConditionOrderUseMatchedBalance:
                            conditionOrderUseMatchedBalance = reader.ReadBool();
                            return(true);

                        case QuikFixTags.LinkedOrderPrice:
                            linkedOrderPrice = reader.ReadDecimal();
                            return(true);

                        case QuikFixTags.Offset:
                            offset = reader.ReadString();
                            return(true);

                        case QuikFixTags.StopSpread:
                            stopSpread = reader.ReadString();
                            return(true);

                        case QuikFixTags.IsMarketTakeProfit:
                            isMarketTakeProfit = reader.ReadBool();
                            return(true);

                        default:
                            return(false);
                        }
                    });

                if (executions == null)
                {
                    return(null);
                }

                var exec = executions.First();

                var condition = new QuikOrderCondition
                {
                    Type                            = (QuikOrderConditionTypes?)type,
                    Result                          = (QuikOrderConditionResults?)result,
                    StopPriceCondition              = (QuikStopPriceConditions?)stopPriceCondition,
                    StopPrice                       = stopPrice,
                    StopLimitPrice                  = stopLimitPrice,
                    IsMarketStopLimit               = isMarketStopLimit,
                    ConditionOrderId                = conditionOrderId,
                    ConditionOrderSide              = (Sides?)conditionOrderSide,
                    ConditionOrderPartiallyMatched  = conditionOrderPartiallyMatched,
                    ConditionOrderUseMatchedBalance = conditionOrderUseMatchedBalance,
                    LinkedOrderPrice                = linkedOrderPrice,
                    LinkedOrderCancel               = linkedOrderCancel,
                    Offset                          = offset == null ? null : offset.ToUnit(),
                    Spread                          = stopSpread == null ? null : stopSpread.ToUnit(),
                    IsMarketTakeProfit              = isMarketTakeProfit,
                };

                if (otherSecurityCode != null)
                {
                    condition.OtherSecurityId = new SecurityId {
                        SecurityCode = otherSecurityCode
                    }
                }
                ;

                if (activeTimeFrom != null && activeTimeTo != null)
                {
                    condition.ActiveTime = new Range <DateTimeOffset>(activeTimeFrom.Value, activeTimeTo.Value);
                }

                exec.Condition = condition;

                SendOutMessage(exec);

                return(true);
            }
            }

            return(base.ProcessTransactionMessage(msgType, reader));
        }
    }
示例#7
0
        public static bool ReadOrderCondition(this IFixReader reader, FixTags tag, TimeSpan dateTimeOffset, QuikOrderCondition condition)
        {
            switch ((QuikFixTags)tag)
            {
            case QuikFixTags.Type:
                condition.Type = (QuikOrderConditionTypes)reader.ReadInt();
                return(true);

            case QuikFixTags.StopPriceCondition:
                condition.StopPriceCondition = (QuikStopPriceConditions)reader.ReadInt();
                return(true);

            case QuikFixTags.ConditionOrderSide:
                condition.ConditionOrderSide = (Sides)reader.ReadInt();
                return(true);

            case QuikFixTags.LinkedOrderCancel:
                condition.LinkedOrderCancel = reader.ReadBool();
                return(true);

            case QuikFixTags.Result:
                condition.Result = (QuikOrderConditionResults)reader.ReadInt();
                return(true);

            case QuikFixTags.OtherSecurityCode:
                condition.OtherSecurityId = new SecurityId {
                    SecurityCode = reader.ReadString()
                };
                return(true);

            case QuikFixTags.StopPrice:
                condition.StopPrice = reader.ReadDecimal();
                return(true);

            case QuikFixTags.StopLimitPrice:
                condition.StopLimitPrice = reader.ReadDecimal();
                return(true);

            case QuikFixTags.IsMarketStopLimit:
                condition.IsMarketStopLimit = reader.ReadBool();
                return(true);

            case QuikFixTags.ActiveTimeFrom:
                if (condition.ActiveTime == null)
                {
                    condition.ActiveTime = new Range <DateTimeOffset>();
                }

                condition.ActiveTime.Min = reader.ReadDateTime().ApplyTimeZone(dateTimeOffset);
                return(true);

            case QuikFixTags.ActiveTimeTo:
                if (condition.ActiveTime == null)
                {
                    condition.ActiveTime = new Range <DateTimeOffset>();
                }

                condition.ActiveTime.Max = reader.ReadDateTime().ApplyTimeZone(dateTimeOffset);
                return(true);

            case QuikFixTags.ConditionOrderId:
                condition.ConditionOrderId = reader.ReadLong();
                return(true);

            case QuikFixTags.ConditionOrderPartiallyMatched:
                condition.ConditionOrderPartiallyMatched = reader.ReadBool();
                return(true);

            case QuikFixTags.ConditionOrderUseMatchedBalance:
                condition.ConditionOrderUseMatchedBalance = reader.ReadBool();
                return(true);

            case QuikFixTags.LinkedOrderPrice:
                condition.LinkedOrderPrice = reader.ReadDecimal();
                return(true);

            case QuikFixTags.Offset:
                condition.Offset = reader.ReadString().ToUnit();
                return(true);

            case QuikFixTags.StopSpread:
                condition.Spread = reader.ReadString().ToUnit();
                return(true);

            case QuikFixTags.IsMarketTakeProfit:
                condition.IsMarketTakeProfit = reader.ReadBool();
                return(true);

            default:
                return(false);
            }
        }