SubmitOrderResponceMessage Receive(SubmitOrderMessage message)
        {
            IImplementation implementation = _implementation;

            if (implementation == null || OperationalState != OperationalStateEnum.Operational)
            {
                return(new SubmitOrderResponceMessage(message.AccountInfo, string.Empty, false));
            }

            SubmitOrderResponceMessage responce;
            string operationResultMessage;
            string id;

            if (message.PerformSynchronous == false)
            {// We need to place order synchronously.
                responce = new SubmitOrderResponceMessage(message.AccountInfo, string.Empty, true);
            }
            else
            {// Just submit the order.
                id = implementation.SubmitOrder(message.AccountInfo, message.Symbol, message.OrderType, message.Volume, message.Slippage,
                                                message.DesiredPrice, message.TakeProfit, message.StopLoss, message.Comment, out operationResultMessage);

                responce = new SubmitOrderResponceMessage(message.AccountInfo, id, string.IsNullOrEmpty(id) == false);
                responce.ResultMessage = operationResultMessage;
            }

            return(responce);
        }
        /// <summary>
        ///
        /// </summary>
        public string SubmitOrder(AccountInfo account, Order order, Symbol symbol, OrderTypeEnum orderType,
                                  int volume, decimal?allowedSlippage, decimal?desiredPrice, decimal?takeProfit, decimal?stopLoss,
                                  string comment, out string operationResultMessage)
        {
            TracerHelper.Trace(this.Name);

            if (OperationalState != OperationalStateEnum.Operational)
            {
                operationResultMessage = "Attempted operations on non operational order executioner.";
                SystemMonitor.Error(operationResultMessage);
                return(null);
            }

            if (account.IsEmpty ||
                string.IsNullOrEmpty(account.Id) ||
                string.IsNullOrEmpty(account.Name))
            {
                operationResultMessage = "Account info on order execution provider not properly assigned.";
                return(null);
            }

            allowedSlippage = ProcessSlippage(allowedSlippage);

            SubmitOrderMessage request = new SubmitOrderMessage(account,
                                                                symbol, orderType, volume, desiredPrice, allowedSlippage, takeProfit, stopLoss, comment);

            request.RequestResponse    = true;
            request.PerformSynchronous = true;

            ResponseMessage response = this.SendAndReceiveResponding <ResponseMessage>
                                           (SourceTransportInfo, request);

            if (response == null)
            {// Time out.
                operationResultMessage = "Failed receive result for order request. In this scenario inconsistency may occur!";
                SystemMonitor.Error(operationResultMessage);
                return(null);
            }

            if (response.OperationResult == false)
            {
                operationResultMessage = response.OperationResultMessage;
                return(null);
            }

            SubmitOrderResponseMessage responseMessage = (SubmitOrderResponseMessage)response;

            operationResultMessage = "Order submited.";

            //RaiseOrderUpdateEvent(account, order.Info, Order.UpdateTypeEnum.Submitted);

            return(responseMessage.OrderId);
        }
        /// <summary>
        /// 
        /// </summary>
        public string SubmitOrder(AccountInfo account, Order order, Symbol symbol, OrderTypeEnum orderType,
            int volume, decimal? allowedSlippage, decimal? desiredPrice, decimal? takeProfit, decimal? stopLoss, 
            string comment, out string operationResultMessage)
        {
            TracerHelper.Trace(this.Name);

            if (OperationalState != OperationalStateEnum.Operational)
            {
                operationResultMessage = "Attempted operations on non operational order executioner.";
                SystemMonitor.Error(operationResultMessage);
                return null;
            }

            if (account.IsEmpty
                || string.IsNullOrEmpty(account.Id)
                || string.IsNullOrEmpty(account.Name))
            {
                operationResultMessage = "Account info on order execution provider not properly assigned.";
                return null;
            }

            allowedSlippage = ProcessSlippage(allowedSlippage);

            SubmitOrderMessage request = new SubmitOrderMessage(account,
                symbol, orderType, volume, desiredPrice, allowedSlippage, takeProfit, stopLoss, comment);

            request.RequestResponse = true;
            request.PerformSynchronous = true;

            ResponseMessage response = this.SendAndReceiveResponding<ResponseMessage>
                (SourceTransportInfo, request);

            if (response == null)
            {// Time out.
                operationResultMessage = "Failed receive result for order request. In this scenario inconsistency may occur!";
                SystemMonitor.Error(operationResultMessage);
                return null;
            }

            if (response.OperationResult == false)
            {
                operationResultMessage = response.OperationResultMessage;
                return null;
            }

            SubmitOrderResponseMessage responseMessage = (SubmitOrderResponseMessage)response;
            operationResultMessage = "Order submited.";

            //RaiseOrderUpdateEvent(account, order.Info, Order.UpdateTypeEnum.Submitted);

            return responseMessage.OrderId;
        }
        SubmitOrderResponseMessage Receive(SubmitOrderMessage message)
        {
            IImplementation implementation = _implementation;
            if (implementation == null || OperationalState != OperationalStateEnum.Operational)
            {
                return new SubmitOrderResponseMessage(message.AccountInfo, string.Empty, false);
            }

            SubmitOrderResponseMessage response;
            string operationResultMessage;
            string id;

            if (message.PerformSynchronous == false)
            {// We need to place order synchronously.
                response = new SubmitOrderResponseMessage(message.AccountInfo, string.Empty, true);
            }
            else
            {// Just submit the order.

                id = implementation.SubmitOrder(message.AccountInfo, message.Symbol, message.OrderType, message.Volume, message.Slippage,
                    message.DesiredPrice, message.TakeProfit, message.StopLoss, message.Comment, out operationResultMessage);

                response = new SubmitOrderResponseMessage(message.AccountInfo, id, string.IsNullOrEmpty(id) == false);
                response.ResultMessage = operationResultMessage;
            }

            return response;
        }