Пример #1
0
        public async Task <OpenOrderResult> PlaceOpeningOrder(TradeDetail trade, IEnumerable <TradeDetail> relatedTrades)
        {
            var market           = trade.Match.BetfairData.Markets.Single(x => x.MarketName == trade.MarketName);
            var runnerId         = market.Runners.Single(x => x.Name == trade.RunnerName).Id;
            var latestRunnerBook = await _runnerService.GetRunnerDetails(market.MarketId, runnerId);

            var orderTick           = _orderPriceFinder.GetPrice(trade.Side, latestRunnerBook.ExchangePrices);
            var openingOrderWrapper = new OrderWrapper(market.MarketId, runnerId, trade.Side, orderTick, PersistenceType.LAPSE);

            var policy = Policy.Handle <MarketSuspendedException>().Or <OrderActionErrorException>().Or <OrderNotPlaceableException>().WaitAndRetry(3, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt * 4)));

            var betReport = await policy.Execute(() => _orderPlacer.PlaceOrder(openingOrderWrapper));

            var betId = betReport.InstructionReports.Single().BetId;

            openingOrderWrapper.AddBetId(betId);
            _sleepService.Sleep(5000);

            var matchReport = await _runnerService.GetRunnerDetails(market.MarketId, runnerId);

            var orderReport = matchReport.Orders.Where(x => x.BetId == betId).Sum(x => x.SizeRemaining);

            if (orderReport != 0)
            {
                var cancelReport = await _orderPlacer.CancelOrder(betId, market.MarketId);

                if (cancelReport.Status == ExecutionReportStatus.SUCCESS)
                {
                    throw new OrderCancelledException(betId);
                }
            }

            return(new OpenOrderResult(trade, openingOrderWrapper));
        }
Пример #2
0
        private void Process()
        {
            if (_placerQueue.Count == 0)
            {
                return;
            }
            var data = _placerQueue.Dequeue();

            if (data.IsNotification)
            {
                switch (data.State)
                {
                case ProcessState.Cancelation:
                    _notificator.OrderCanceled(data.Order.Id);
                    break;

                case ProcessState.Movement:
                    _notificator.OrderMoved(data.Order.Id);
                    break;

                case ProcessState.Placing:
                    _notificator.OrderPlaced(data.Order.Id);
                    break;

                case ProcessState.Filled:
                    _notificator.OrderFilled(data.Order.Id, data.Order.Size, data.Order.Price);
                    break;
                }
            }
            else
            {
                switch (data.State)
                {
                case ProcessState.Cancelation:
                    _placer.CancelOrder(data.Order.Id);
                    AddPending(data.Order, ProcessState.Cancelation);
                    break;

                case ProcessState.Movement:
                    _placer.MoveOrder(data.Order.Id, data.Order.Price);
                    AddPending(data.Order, ProcessState.Movement);
                    break;

                case ProcessState.Placing:
                    _placer.PlaceOrder(data.Order.Id, data.Order.Price, data.Order.Size);
                    AddPending(data.Order, ProcessState.Placing);
                    break;
                }
            }
        }