public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState,
            IMarketStateCollection newState)
        {            

            var result = new MarketRuleResultIntent();

            if (oldState == null)
                return result;
            
            var deletedMarkets =
                newState.Markets.Select(marketId => newState[marketId])
                    .Where(marketState => marketState.IsDeleted && oldState.HasMarket(marketState.Id) && !oldState[marketState.Id].IsDeleted)
                    .ToList();

            var newDeletedMarketState = deletedMarkets.Select(CreateSuspendedMarket).ToList();

            if (deletedMarkets.Any())
            {
                newDeletedMarketState.ForEach(m =>
                {
                    _logger.DebugFormat("market rule={0} => {1} of fixtureId={2} was deleted from UDAPI - it will be suspended", Name, m, fixture.Id);
                    result.AddMarket(m, new MarketRuleAddIntent(MarketRuleAddIntent.OperationType.CHANGE_SELECTIONS));
                });
            }
            
            return result;

        }
        private Fixture GetUnsuspendedFixture(IMarketStateCollection state, out List <IMarketState> marketStates)
        {
            marketStates = new List <IMarketState>();

            var fixture = new Fixture
            {
                Id          = state.FixtureId,
                MatchStatus = ((int)state.FixtureStatus).ToString(),
                Sequence    = state.FixtureSequence
            };

            foreach (var mkt_id in state.Markets)
            {
                var marketState = state[mkt_id];
                if (marketState == null)
                {
                    continue;
                }

                marketStates.Add(marketState);
                //only unsuspend market if it's suspended by Adapter and not suspended in the feed
                if (marketState.IsForcedSuspended && !marketState.IsSuspended)
                {
                    fixture.Markets.Add(CreateMarket(state[mkt_id], false));
                }
            }

            return(fixture);
        }
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
            MarketRuleResultIntent intent = new MarketRuleResultIntent();

            // only apply delta rule on a full snapshot
            if (fixture.Tags == null || !fixture.Tags.Any() || oldState == null)
                return intent;


            foreach (var mkt in fixture.Markets)
            {
                if (oldState.HasMarket(mkt.Id))
                {
                    IMarketState state = oldState[mkt.Id];
                    
                    // do not apply the delta rule on markets which have 
                    // been put in a forced suspended state
                    if (state.IsForcedSuspended)
                        continue;

                    if (Severity == DeltaRuleSeverity.REMOVE_SELECTIONS)
                    {
                        ApplyDeltaRule_RemovingSelections(fixture, mkt, state, intent);
                    }
                    else if (Severity == DeltaRuleSeverity.REMOVE_MARKETS)
                    {
                        ApplyDeltaRule_RemovingMarkets(fixture, mkt, state, intent);
                    }
                }
            }

            return intent;
        }
示例#4
0
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState,
                                             IMarketStateCollection newState)
        {
            var result = new MarketRuleResultIntent();

            if (oldState == null)
            {
                return(result);
            }

            var deletedMarkets =
                newState.Markets.Select(marketId => newState[marketId])
                .Where(marketState => marketState.IsDeleted && oldState.HasMarket(marketState.Id) && !oldState[marketState.Id].IsDeleted)
                .ToList();

            var newDeletedMarketState = deletedMarkets.Select(CreateSuspendedMarket).ToList();

            if (deletedMarkets.Any())
            {
                newDeletedMarketState.ForEach(m =>
                {
                    _logger.DebugFormat("market rule={0} => {1} of fixtureId={2} was deleted from UDAPI - it will be suspended", Name, m, fixture.Id);
                    result.AddMarket(m, new MarketRuleAddIntent(MarketRuleAddIntent.OperationType.CHANGE_SELECTIONS));
                });
            }

            return(result);
        }
        /// <summary>
        ///
        ///     Remove markets from snapshot/update when:
        ///     current market state is inactive AND the previous state was inactive too (with no change in status or name)
        ///
        ///     NB: If there is a change in market's name or status then will not be removed
        ///
        /// </summary>
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
            var result = new MarketRuleResultIntent();

            var inactiveMarkets = fixture.Markets.Where(
                m => (oldState != null && oldState.HasMarket(m.Id) && oldState[m.Id].IsEqualTo(newState[m.Id])) &&
                (!m.IsActive && !oldState[m.Id].IsActive));

            var start        = DateTime.UtcNow;
            var inactiveList = inactiveMarkets.ToList();



            foreach (var market in inactiveList)
            {
                result.MarkAsRemovable(market);
                if (logDetailedMarketRules)
                {
                    _Logger.DebugFormat("market rule={0} => {1} of fixtureId={2} is marked as removable", Name, market, fixture.Id);
                }
            }


            _Logger.Info($"Marking markets as removable took marketRulesTime={(DateTime.UtcNow - start).TotalSeconds.ToString("N")} marketsCount={fixture.Markets.Count} removableCount={inactiveList.Count} {fixture}");

            return(result);
        }
示例#6
0
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
            var result = new MarketRuleResultIntent();

            if (!fixture.IsMatchOver || oldState == null)
            {
                return(result);
            }

            var markets = fixture.Markets.ToDictionary(m => m.Id);

            // get list of markets which are either no longer in snapshot or are in the snapshot and are not resulted
            // markets which were already priced (activated) should be ignored
            var marketsNotPresentInTheSnapshot = new List <IMarketState>();

            foreach (var mkt in newState.Markets)
            {
                IMarketState mkt_state = newState[mkt];
                if (!mkt_state.IsResulted && (!markets.ContainsKey(mkt_state.Id) || !markets[mkt_state.Id].IsResulted))
                {
                    marketsNotPresentInTheSnapshot.Add(mkt_state);
                }
            }

            foreach (var mkt_state in marketsNotPresentInTheSnapshot)
            {
                if (mkt_state.HasBeenActive)
                {
                    _logger.DebugFormat("market rule={0} => marketId={1} of {2} was priced during the fixture lifetime but has NOT been settled on match over.",
                                        Name, mkt_state.Id, fixture);
                    continue;
                }

                if (!mkt_state.HasBeenProcessed)
                {
                    _logger.DebugFormat("market rule={0} => marketId={1} of {2} was never passed to the plugin.", Name, mkt_state.Id, fixture);
                    continue;
                }

                var market = fixture.Markets.FirstOrDefault(m => m.Id == mkt_state.Id);
                if (market == null)
                {
                    _logger.DebugFormat("market rule={0} => marketId={1} of {2} is marked to be voided", Name, mkt_state.Id, fixture);

                    result.AddMarket(CreateSettledMarket(mkt_state), new MarketRuleAddIntent(MarketRuleAddIntent.OperationType.SETTLE_SELECTIONS));
                }
                else
                {
                    _logger.DebugFormat("market rule={0} => marketId={1} of {2} that was in the snapshot but wasn't resulted is marked to be voided",
                                        Name, market.Id, fixture);

                    Action <Market>      action = x => x.Selections.ForEach(s => s.Status = SelectionStatus.Void);
                    MarketRuleEditIntent edit   = new MarketRuleEditIntent(action, MarketRuleEditIntent.OperationType.CHANGE_SELECTIONS);
                    result.EditMarket(market, edit);
                }
            }

            return(result);
        }
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
         
            var result = new MarketRuleResultIntent();

            if (!fixture.IsMatchOver || oldState == null)
                return result;

            var markets = fixture.Markets.ToDictionary(m => m.Id);

            // get list of markets which are either no longer in snapshot or are in the snapshot and are not resulted
            // markets which were already priced (activated) should be ignored
            var marketsNotPresentInTheSnapshot = new List<IMarketState>();
            foreach (var mkt in newState.Markets)
            {
                IMarketState mkt_state = newState[mkt];
                if (!mkt_state.IsResulted && (!markets.ContainsKey(mkt_state.Id) || !markets[mkt_state.Id].IsResulted))
                    marketsNotPresentInTheSnapshot.Add(mkt_state);
            }
            
            foreach (var mkt_state in marketsNotPresentInTheSnapshot)
            {
                if (mkt_state.HasBeenActive)
                {
                    _logger.DebugFormat("market rule={0} => marketId={1} of {2} was priced during the fixture lifetime but has NOT been settled on match over.", 
                        Name, mkt_state.Id, fixture);
                    continue;
                }

                if (!mkt_state.HasBeenProcessed)
                {
                    _logger.DebugFormat("market rule={0} => marketId={1} of {2} was never passed to the plugin.", Name, mkt_state.Id, fixture);
                    continue;
                }

                var market = fixture.Markets.FirstOrDefault(m => m.Id == mkt_state.Id);
                if (market == null)
                {
                    _logger.DebugFormat("market rule={0} => marketId={1} of {2} is marked to be voided", Name, mkt_state.Id, fixture);

                    result.AddMarket(CreateSettledMarket(mkt_state), new MarketRuleAddIntent(MarketRuleAddIntent.OperationType.SETTLE_SELECTIONS));
                }
                else
                {
                    _logger.DebugFormat("market rule={0} => marketId={1} of {2} that was in the snapshot but wasn't resulted is marked to be voided", 
                        Name, market.Id, fixture);

                    Action<Market> action = x => x.Selections.ForEach(s => s.Status = SelectionStatus.Void);
                    MarketRuleEditIntent edit = new MarketRuleEditIntent(action, MarketRuleEditIntent.OperationType.CHANGE_SELECTIONS);
                    result.EditMarket(market, edit);
                }

            }

            return result;
        }
        public void Suspend(Fixture fixture, SuspensionReason reason = SuspensionReason.FIXTURE_DISPOSING)
        {
            var fixtureId = fixture.Id;

            Action <IMarketStateCollection> action;

            switch (reason)
            {
            case SuspensionReason.FIXTURE_DISPOSING:
                action = _disposing;
                break;

            case SuspensionReason.DISCONNECT_EVENT:
                action = _disconnected;
                break;

            case SuspensionReason.FIXTURE_DELETED:
                action = _fixtureDeleted;
                break;

            case SuspensionReason.FIXTURE_ERRORED:
                action = _error;
                break;

            default:
                action = _default;
                break;
            }

            IMarketStateCollection state = _stateProvider.GetMarketsState(fixtureId);

            if (state == null)
            {
                _logger.WarnFormat("State is not present for fixtureId={0} - can't suspend with reason={1}",
                                   fixtureId, reason);
                return;
            }

            _logger.InfoFormat("Performing suspension for fixtureId={0} due reason={1}", fixtureId, reason);

            try
            {
                action(state);
            }
            catch (Exception e)
            {
                _logger.Error($"An error occured while performing suspend action on fixtureId={fixtureId}", e);
                throw new PluginException($"Plugin Suspend Fixture with fixtureId={fixtureId} error occured", e);
            }
        }
        /// <summary>
        /// 
        ///     Remove markets from snapshot/update when: 
        ///     current market state is inactive AND the previous state was inactive too (with no change in status or name)
        /// 
        ///     NB: If there is a change in market's name or status then will not be removed
        /// 
        /// </summary>
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
            var result = new MarketRuleResultIntent();

            var inactiveMarkets = fixture.Markets.Where(
                m => (oldState != null && oldState.HasMarket(m.Id) && oldState[m.Id].IsEqualTo(newState[m.Id]))
                        && (!m.IsActive && !oldState[m.Id].IsActive));

            foreach (var market in inactiveMarkets.ToList())
            {
                result.MarkAsRemovable(market);
                _Logger.DebugFormat("market rule={0} => {1} of fixtureId={2} is marked as removable", Name, market, fixture.Id);
            }

            return result;
        }
        /// <summary>
        ///
        ///     Remove markets from snapshot/update when:
        ///     current market state is inactive AND the previous state was inactive too (with no change in status or name)
        ///
        ///     NB: If there is a change in market's name or status then will not be removed
        ///
        /// </summary>
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
            var result = new MarketRuleResultIntent();

            var inactiveMarkets = fixture.Markets.Where(
                m => (oldState != null && oldState.HasMarket(m.Id) && oldState[m.Id].IsEqualTo(newState[m.Id])) &&
                (!m.IsActive && !oldState[m.Id].IsActive));

            foreach (var market in inactiveMarkets.ToList())
            {
                result.MarkAsRemovable(market);
                _Logger.DebugFormat("market rule={0} => {1} of fixtureId={2} is marked as removable", Name, market, fixture.Id);
            }

            return(result);
        }
        private static Fixture GetFixtureWithSuspendedMarkets(IMarketStateCollection state, out IEnumerable <IMarketState> includedMarketStates)
        {
            includedMarketStates = new List <IMarketState>();

            var fixture = new Fixture
            {
                Id          = state.FixtureId,
                MatchStatus = ((int)state.FixtureStatus).ToString(),
                Sequence    = state.FixtureSequence
            };

            foreach (var mkt_id in state.Markets)
            {
                ((List <IMarketState>)includedMarketStates).Add(state[mkt_id]);
                fixture.Markets.Add(CreateMarket(state[mkt_id]));
            }

            return(fixture);
        }
        public void Unsuspend(string fixtureId)
        {
            IMarketStateCollection state = _stateProvider.GetMarketsState(fixtureId);
            List <IMarketState>    marketStates;

            if (state == null)
            {
                _logger.WarnFormat("State is not present for fixtureId={0} - can't unsuspend", fixtureId);
                return;
            }

            var fixture = GetUnsuspendedFixture(state, out marketStates);

            if (fixture.Markets.Any())
            {
                _logger.InfoFormat("Unsuspending previously suspended markets in {0}", fixture);
                _plugin.ProcessStreamUpdate(fixture);
            }

            ((IUpdatableMarketStateCollection)state).OnMarketsForcedUnsuspension(marketStates);
        }
示例#13
0
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
            MarketRuleResultIntent intent = new MarketRuleResultIntent();

            // only apply delta rule on a full snapshot
            if (fixture.Tags == null || !fixture.Tags.Any() || oldState == null)
            {
                return(intent);
            }


            foreach (var mkt in fixture.Markets)
            {
                if (oldState.HasMarket(mkt.Id))
                {
                    IMarketState state = oldState[mkt.Id];

                    // do not apply the delta rule on markets which have
                    // been put in a forced suspended state
                    if (state.IsForcedSuspended)
                    {
                        continue;
                    }

                    if (Severity == DeltaRuleSeverity.REMOVE_SELECTIONS)
                    {
                        ApplyDeltaRule_RemovingSelections(fixture, mkt, state, intent);
                    }
                    else if (Severity == DeltaRuleSeverity.REMOVE_MARKETS)
                    {
                        ApplyDeltaRule_RemovingMarkets(fixture, mkt, state, intent);
                    }
                }
            }

            return(intent);
        }
        public void Unsuspend(Fixture fixture)
        {
            IMarketStateCollection state = _stateProvider.GetMarketsState(fixture.Id);
            List <IMarketState>    marketStates;

            if (state == null)
            {
                _logger.WarnFormat($"State is not present for {fixture} - can't unsuspend");
                return;
            }

            var unsuspendedFixture = GetUnsuspendedFixture(state, out marketStates);

            if (unsuspendedFixture.Markets.Any())
            {
                _logger.InfoFormat("Unsuspending previously suspended markets in {0}", unsuspendedFixture);
                try
                {
                    _plugin.ProcessStreamUpdate(unsuspendedFixture);
                }
                catch (Exception ex)
                {
                    throw new PluginException($"Plugin ProcessStreamUpdate {fixture} error occured", ex);
                }
            }

            ((IUpdatableMarketStateCollection)state).OnMarketsForcedUnsuspension(marketStates);

            try
            {
                _plugin.UnSuspend(fixture);
            }
            catch (Exception ex)
            {
                throw new PluginException($"Plugin UnSuspend {fixture} error occured", ex);
            }
        }
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
            if (_includedSports == null)
            {
                throw new Exception($"Apply Market Rule _includedSports=NULL {fixture}");
            }

            if (_includedSports == null)
            {
                throw new Exception($"Apply Market Rule newState=NULL {fixture}");
            }

            if (_includedSports == null)
            {
                throw new Exception($"Apply Market Rule newState.Sport=NULL {fixture}");
            }


            var result = new MarketRuleResultIntent();

            if (_includedSports.Contains(newState.Sport.ToLower()))
            {
                foreach (var mkt in fixture.Markets)
                {
                    string type = string.Format("{0}.{1}", newState.Sport, mkt.Type).ToLower();

                    if (_excludedMarketTypes.Contains(type))
                    {
                        _Logger.DebugFormat("market rule={0} => {1} of {2} is excluded from rule due its type={3}",
                                            Name, mkt, fixture, mkt.Type);

                        continue;
                    }

                    var oldMarketState = oldState != null ? oldState[mkt.Id] : null;
                    var newMarketState = newState[mkt.Id];

                    if (oldMarketState == null)
                    {
                        //must be a snapshot then
                        if (newMarketState.IsActive)
                        {
                            //create market
                            _Logger.DebugFormat("market rule={0} => {1} of {2} is created", Name, mkt, fixture);
                            result.MarkAsUnRemovable(mkt);
                        }
                        else
                        {
                            //dont create market
                            _Logger.DebugFormat("market rule={0} => {1} of {2} is not created because market isActive={3}", Name, mkt, fixture, newMarketState.IsActive);
                            result.MarkAsRemovable(mkt);
                        }
                    }
                    else
                    {
                        if (oldMarketState.HasBeenActive)
                        {
                            continue;
                        }
                        if (newMarketState.IsActive)
                        {
                            //create
                            Action <Market> editMarketAction = (m =>
                            {
                                if (newMarketState.TagsCount == 0)
                                {
                                    return;
                                }

                                foreach (var tagKey in newMarketState.TagKeys)
                                {
                                    m.AddOrUpdateTagValue(tagKey, newMarketState.GetTagValue(tagKey));
                                }

                                foreach (var sel in m.Selections)
                                {
                                    var selState = newMarketState[sel.Id];
                                    foreach (var tagKey in selState.TagKeys)
                                    {
                                        sel.AddOrUpdateTagValue(tagKey, selState.GetTagValue(tagKey));
                                    }
                                }
                            });

                            var mri = new MarketRuleEditIntent(editMarketAction, MarketRuleEditIntent.OperationType.CHANGE_DATA);
                            if (logDetailedMarketRules)
                            {
                                _Logger.DebugFormat("market rule={0} => {1} of {2} is created", Name, mkt, fixture);
                            }
                            result.EditMarket(mkt, mri);
                        }
                        else
                        {
                            //dont create market
                            if (logDetailedMarketRules)
                            {
                                _Logger.DebugFormat("market rule={0} => {1} of {2} is not created because market isActive={3}", Name, mkt, fixture, newMarketState.IsActive);
                            }
                            result.MarkAsRemovable(mkt);
                        }
                    }
                }
            }

            return(result);
        }
        private static Fixture GetFixtureWithSuspendedMarkets(IMarketStateCollection state, out IEnumerable<IMarketState> includedMarketStates)
        {
            includedMarketStates = new List<IMarketState>();

            var fixture = new Fixture
            {
                Id = state.FixtureId,
                MatchStatus = ((int) state.FixtureStatus).ToString(),
                Sequence = state.FixtureSequence
            };

            foreach (var mkt_id in state.Markets)
            {
                ((List<IMarketState>)includedMarketStates).Add(state[mkt_id]);
                fixture.Markets.Add(CreateMarket(state[mkt_id]));
            }

            return fixture;
        }
        private Fixture GetUnsuspendedFixture(IMarketStateCollection state,out List<IMarketState> marketStates)
        {
            marketStates = new List<IMarketState>();

            var fixture = new Fixture
            {
                Id = state.FixtureId,
                MatchStatus = ((int)state.FixtureStatus).ToString(),
                Sequence = state.FixtureSequence
            };

            foreach (var mkt_id in state.Markets)
            {
                var marketState = state[mkt_id];
                if(marketState == null)
                    continue;

                marketStates.Add(marketState);
                //only unsuspend market if it's suspended by Adapter and not suspended in the feed
                if (marketState.IsForcedSuspended && !marketState.IsSuspended)
                {
                    fixture.Markets.Add(CreateMarket(state[mkt_id], false));
                }

            }

            return fixture;
        }
        public IMarketRuleResultIntent Apply(Fixture fixture, IMarketStateCollection oldState, IMarketStateCollection newState)
        {
            var result = new MarketRuleResultIntent();

            if (_includedSports.Contains(newState.Sport.ToLower()))
            {
                
                foreach (var mkt in fixture.Markets)
                {
                    string type = string.Format("{0}.{1}", newState.Sport, mkt.Type).ToLower();

                    if (_excludedMarketTypes.Contains(type))
                    {
                        _Logger.DebugFormat("market rule={0} => {1} of {2} is excluded from rule due its type={3}",
                            Name, mkt, fixture, mkt.Type);

                        continue;
                    }

                    var oldMarketState = oldState != null ? oldState[mkt.Id] : null;
                    var newMarketState = newState[mkt.Id];

                    if (oldMarketState == null)
                    {
                        //must be a snapshot then
                        if (newMarketState.IsActive)
                        {
                            //create market
                            _Logger.DebugFormat("market rule={0} => {1} of {2} is created", Name, mkt, fixture);
                            result.MarkAsUnRemovable(mkt);
                        }
                        else
                        {
                            //dont create market
                            _Logger.DebugFormat("market rule={0} => {1} of {2} is not created", Name, mkt, fixture);
                            result.MarkAsRemovable(mkt);
                        }
                    }
                    else
                    {
                        if (oldMarketState.HasBeenActive) continue;
                        if (newMarketState.IsActive)
                        {
                            //create
                            Action<Market> editMarketAction = (m =>
                            {
                                if (newMarketState.TagsCount == 0)
                                    return;

                                foreach (var tagKey in newMarketState.TagKeys)
                                {
                                    m.AddOrUpdateTagValue(tagKey, newMarketState.GetTagValue(tagKey));
                                }

                                foreach (var sel in m.Selections)
                                {
                                    var selState = newMarketState[sel.Id];
                                    foreach (var tagKey in selState.TagKeys)
                                    {
                                        sel.AddOrUpdateTagValue(tagKey, selState.GetTagValue(tagKey));
                                    }
                                }
                            });

                            var mri = new MarketRuleEditIntent(editMarketAction, MarketRuleEditIntent.OperationType.CHANGE_DATA);
                            _Logger.DebugFormat("market rule={0} => {1} of {2} is created", Name, mkt, fixture);
                            result.EditMarket(mkt, mri);
                        }
                        else
                        {
                            //dont create market
                            _Logger.DebugFormat("market rule={0} => {1} of {2} is not created", Name, mkt, fixture);
                            result.MarkAsRemovable(mkt);
                        }
                    }
                }                
            }

            return result;
        }