public ExecutionMessage(ExecutionMessage executionMessage) : base(executionMessage)
 {
     Id = executionMessage.Id;
     this.order = executionMessage.Order;
     OrderId = executionMessage.OrderId;
     ClOrderId = executionMessage.ClOrderId;
     ProviderOrderId = executionMessage.ProviderOrderId;
     this.instrument = executionMessage.Instrument;
     InstrumentId = executionMessage.InstrumentId;
     ClientId = executionMessage.ClientId;
     IsLoaded = executionMessage.IsLoaded;
     CurrencyId = executionMessage.CurrencyId;
     Fields = new ObjectTable(executionMessage.Fields);
 }

        public void Register(Order order)
        {
            if (order.Id != -1)
            {
                Console.WriteLine($"OrderManager::Register Error Order is already registered : id = {order.Id}");
                return;
            }

            lock (this.obj)
                order.Id = this.counter++;

            if (this.framework.Mode == FrameworkMode.Realtime && string.IsNullOrEmpty(order.ClOrderId))
                order.ClOrderId = $"{this.framework.Clock.DateTime} {order.Id}";
        }

        public override void OnOrder(Order order)
        {
            if (order.Text == "TakeProfit")
                order.OCA = (++OCACount).ToString();

            if (order.Text == "StopLoss")
                order.OCA = OCACount.ToString();

            if (order.Text == "StopLoss")
                stopLossOrder = order;

            if (order.Text == "StopExit" || order.Text == "StopSession")
                framework.OrderManager.Cancel(stopLossOrder);

            base.OnOrder(order);
        }

        public void Cancel(Order order)
        {
            if (order.IsNotSent)
                throw new ArgumentException($"Can not cancel order that is not sent {order}");

            var command = new ExecutionCommand(ExecutionCommandType.Cancel, order)
            {
                DateTime = this.framework.Clock.DateTime,
                OrderId = order.Id,
                ClOrderId = order.ClOrderId,
                ProviderOrderId = order.ProviderOrderId,
                ProviderId = order.ProviderId,
                RouteId = order.RouteId,
                PortfolioId = order.PortfolioId
            };
            command.DateTime = order.DateTime;
            command.Instrument = order.Instrument;
            command.InstrumentId = order.InstrumentId;
            command.Provider = order.Provider;
            command.Portfolio = order.Portfolio;
            command.Side = order.Side;
            command.OrdType = order.Type;
            command.TimeInForce = order.TimeInForce;
            command.Price = order.Price;
            command.StopPx = order.StopPx;
            command.Qty = order.Qty;
            command.OCA = order.OCA;
            command.Text = order.Text;
            command.Account = order.Account;
            command.ClientID = order.ClientID;
            command.ClientId = order.ClientId;
            Messages.Add(command);
            order.OnExecutionCommand(command);
            this.framework.EventServer.OnExecutionCommand(command);
            if (IsPersistent)
                Server?.Save(command, -1);
            order.Provider.Send(command);
        }

 public ExecutionCommand(ExecutionCommandType type, Order order)
     : this()
 {
     Type = type;
     Order = order;
     OrderId = order.Id;
     ProviderId = order.ProviderId;
     RouteId = order.RouteId;
     AlgoId = order.AlgoId;
     PortfolioId = order.PortfolioId;
     InstrumentId = order.InstrumentId;
     TransactTime = order.TransactTime;
     DateTime = order.DateTime;
     Instrument = order.Instrument;
     Provider = order.Provider;
     Portfolio = order.Portfolio;
     Side = order.Side;
     OrdType = order.Type;
     TimeInForce = order.TimeInForce;
     ExpireTime = order.ExpireTime;
     Price = order.Price;
     StopPx = order.StopPx;
     Qty = order.Qty;
     MinQty = order.MinQty;
     PegDifference = order.PegDifference;
     ExecInst = order.ExecInst;
     OCA = order.OCA;
     Text = order.Text;
     Account = order.Account;
     ClientID = order.ClientID;
     Fields = new ObjectTable(order.Fields);
 }

        public OrderProcessor(SpreadSellSide strategy, ExecutionCommand command)
        {
            // Add current processor to SellSide processor's list. 
            strategy.processors.AddLast(this);

            // Init OrderProcessor fields.
            this.strategy = strategy;
            this.command = command;
            order = command.Order;
            spreadInstrument = order.Instrument;
            orders = new Dictionary<Order, Leg>();

            // Send leg orders if order type is market.
            if (order.Type == OrderType.Market)
                SendLegOrders();
        }

 private void method_8(Order order_0, Bid bid_0, Ask ask_0)
 {
 }

 private void method_6(Order order_0)
 {
 }

        private void UpdateExitLimit()
        {
            if (exitOrder != null && !exitOrder.IsDone)
                Cancel(exitOrder);

            if (HasPosition(Instrument))
            {
                if (Position.Side == PositionSide.Long)
                    exitOrder = SellLimitOrder(Instrument, Qty, sma.Last, "Exit");
                else
                    exitOrder = BuyLimitOrder(Instrument, Qty, sma.Last, "Exit");

                Send(exitOrder);
            }
        }