/// <summary> /// Returns null if it has filtered out the event /// </summary> /// <param name="universeEvent"> /// The universe Event. /// </param> /// <returns> /// The <see cref="IUniverseEvent"/>. /// </returns> public IUniverseEvent Filter(IUniverseEvent universeEvent) { switch (universeEvent.StateChange) { case UniverseStateEvent.Order: case UniverseStateEvent.OrderPlaced: break; default: return(universeEvent); } var order = universeEvent.UnderlyingEvent as Order; if (order == null) { this.logger.LogError( "encountered an unexpected type for the underlying value of a trade event. Not filtering."); return(universeEvent); } var excludeUniverseEvent = this.Filter(order); if (excludeUniverseEvent) { return(null); } return(universeEvent); }
/// <summary> /// The trade filled delay. /// </summary> /// <param name="universeEvent"> /// The universe event. /// </param> private void TradeFilledDelay(IUniverseEvent universeEvent) { if (!(universeEvent.UnderlyingEvent is Order value)) { return; } if (value.FilledDate == null) { this.logger?.LogError($"Trade filled with null fill date {value.Instrument.Identifiers}"); return; } this.logger?.LogTrace($"Trade Filled event (status changed - delayed) in base universe rule occuring for {this.name} | event/universe time {universeEvent.EventTime} | reddeer order id (p key){value.ReddeerOrderId}"); this.UniverseDateTime = universeEvent.EventTime; var updatedHistory = this.UpdateTradeFilledTradingHistories( value, this.DelayedTradingFillsHistory, this.TradeBackwardWindowSize, this.ForwardWindowSize); this.RunOrderFilledEventDelayed(updatedHistory); }
private void StockTick(IUniverseEvent value) { this.Analytics.StockTickReddeerCount += 1; var exchangeFrame = (EquityIntraDayTimeBarCollection)value.UnderlyingEvent; if (exchangeFrame?.Securities == null) { return; } lock (this._securityIdLock) { if (exchangeFrame?.Securities?.Count != 0) { foreach (var sec in exchangeFrame.Securities) { if (sec?.Security?.Identifiers == null) { continue; } if (!this._securityIds.ContainsKey(sec.Security.Identifiers)) { this._securityIds.Add( new KeyValuePair <InstrumentIdentifiers, FinancialInstrument>( sec.Security.Identifiers, sec.Security)); } } } } }
/// <summary> /// The eschaton. /// </summary> /// <param name="universeEvent"> /// The universe event. /// </param> private void Eschaton(IUniverseEvent universeEvent) { this.logger?.LogInformation($"Eschaton in base universe rule occuring for {this.name} | event/universe time {universeEvent.EventTime}"); this.UniverseDateTime = universeEvent.EventTime; this.HasReachedEndOfUniverse = true; this.EndOfUniverse(); }
public void Setup() { this.streamRule = A.Fake <IFixedIncomeHighProfitsStreamRule>(); this.marketClosureRule = A.Fake <IFixedIncomeHighProfitsMarketClosureRule>(); this.parameters = A.Fake <IHighProfitsRuleFixedIncomeParameters>(); this.logger = A.Fake <ILogger <FixedIncomeHighProfitsRule> >(); this.universeEvent = A.Fake <IUniverseEvent>(); }
/// <summary> /// The filter on account. /// </summary> /// <param name="value"> /// The value. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> private bool FilterOnAccount(IUniverseEvent value) { return(this.FilterOnOrderAttribute( value, this.accounts, i => i.OrderClientAccountAttributionId, "Accounts")); }
/// <summary> /// The on next. /// </summary> /// <param name="value"> /// The value. /// </param> public void OnNext(IUniverseEvent value) { if (this.FilterOnAccount(value)) { return; } if (this.FilterOnTraders(value)) { return; } if (this.FilterOnMarkets(value)) { return; } if (this.highMarketCapFilter.Filter(value)) { return; } if (this.FilterOnFund(value)) { return; } if (this.FilterOnStrategy(value)) { return; } if (this.FilterOnSector(value)) { return; } if (this.FilterOnIndustry(value)) { return; } if (this.FilterOnRegion(value)) { return; } if (this.FilterOnCountry(value)) { return; } this.logger.LogInformation($"is not filtering event at {value.EventTime} with type {value.StateChange}"); foreach (var obs in this.universeObservers) { obs.Value?.OnNext(value); } }
public void Do_XNullEvent_ReturnLess() { IUniverseEvent x = null; IUniverseEvent y = new UniverseEvent(UniverseStateEvent.Genesis, DateTime.UtcNow, new object()); var comparer = new UniverseEventComparer(); var result = comparer.Compare(x, y); Assert.AreEqual(result, -1); }
public void Do_TwoNullEvents_ReturnEqual() { IUniverseEvent x = null; IUniverseEvent y = null; var comparer = new UniverseEventComparer(); var result = comparer.Compare(x, y); Assert.AreEqual(result, 0); }
private void EquityInterDay(IUniverseEvent universeEvent) { if (!(universeEvent.UnderlyingEvent is EquityInterDayTimeBarCollection value)) { return; } this._logger?.LogInformation($"Equity inter day event in HighMarketCapFilter occuring for {_name} | event/universe time {universeEvent.EventTime} | MIC {value.Exchange?.MarketIdentifierCode} | timestamp {value.Epoch} | security count {value.Securities?.Count ?? 0}"); this._universeEquityInterdayCache.Add(value); }
/// <summary> /// The filter on order attribute. /// </summary> /// <param name="value"> /// The value. /// </param> /// <param name="filter"> /// The filter. /// </param> /// <param name="propertyLens"> /// The property lens. /// </param> /// <param name="filterName"> /// The filter name. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> private bool FilterOnOrderAttribute( IUniverseEvent value, RuleFilter filter, Func <Order, string> propertyLens, string filterName) { if (filter == null) { return(false); } if (filter.Type == RuleFilterType.None) { return(false); } if (value == null) { return(false); } if (value.StateChange != UniverseStateEvent.Order && value.StateChange != UniverseStateEvent.OrderPlaced) { return(false); } var frame = (Order)value.UnderlyingEvent; if (frame == null) { return(false); } var filterResult = false; switch (filter.Type) { case RuleFilterType.Include: filterResult = !filter.Ids.Contains(propertyLens(frame), StringComparer.InvariantCultureIgnoreCase); break; case RuleFilterType.Exclude: filterResult = filter.Ids.Contains(propertyLens(frame), StringComparer.InvariantCultureIgnoreCase); break; } if (filterResult) { this.logger.LogInformation($"{filterName} filtering out order with id {frame.ReddeerOrderId}"); } return(filterResult); }
/// <summary> /// The fixed income inter day. /// </summary> /// <param name="universeEvent"> /// The universe event. /// </param> private void FixedIncomeInterDay(IUniverseEvent universeEvent) { if (!(universeEvent.UnderlyingEvent is FixedIncomeInterDayTimeBarCollection value)) { return; } this.logger?.LogInformation($"Fixed income inter day event in base universe rule occuring for {this.name} | event/universe time {universeEvent.EventTime} | MIC {value.Exchange?.MarketIdentifierCode} | timestamp {value.Epoch} | security count {value.Securities?.Count ?? 0}"); this.UniverseDateTime = universeEvent.EventTime; this.UniverseFixedIncomeInterdayCache.Add(value); }
/// <summary> /// The fund factor. /// </summary> /// <param name="value"> /// The value. /// </param> private void FundFactor(IUniverseEvent value) { var data = (Order)value.UnderlyingEvent; if (data == null) { return; } if (string.IsNullOrWhiteSpace(data.OrderFund) && string.IsNullOrWhiteSpace(data.OrderClientAccountAttributionId) && !this.aggregateNonFactorableIntoOwnCategory) { return; } lock (this.accountLock) { var orderFund = data.OrderFund; if (string.IsNullOrWhiteSpace(orderFund)) { orderFund = data.OrderClientAccountAttributionId ?? string.Empty; } if (string.IsNullOrWhiteSpace(orderFund)) { orderFund = string.Empty; } if (!this.fundFactors.ContainsKey(orderFund)) { var kvp = new KeyValuePair <string, IUniverseRule>( orderFund, this.cloneSource.Clone(new FactorValue(ClientOrganisationalFactors.Fund, orderFund))); this.fundFactors.Add(kvp); } if (this.fundFactors.ContainsKey(orderFund)) { this.logger.LogInformation( $"has a fund organisational factor and found a rule for fund {orderFund}"); this.fundFactors.TryGetValue(orderFund, out var rule); rule?.OnNext(value); } else { this.logger.LogInformation( $"has a fund organisational factor but could not find a rule for {orderFund}"); } } }
/// <summary> /// The market closed. /// </summary> /// <param name="universeEvent"> /// The universe event. /// </param> private void MarketClosed(IUniverseEvent universeEvent) { if (!(universeEvent.UnderlyingEvent is MarketOpenClose value)) { return; } this.logger?.LogInformation($"Market closed event in base universe rule occuring for {this.name} | event/universe time {universeEvent.EventTime} | MIC {value.MarketId} | Open {value.MarketOpen} | Close {value.MarketClose}"); this.UniverseDateTime = universeEvent.EventTime; this.MarketClose(value); }
/// <summary> /// The genesis. /// </summary> /// <param name="universeEvent"> /// The universe event. /// </param> private void Genesis(IUniverseEvent universeEvent) { if (!(universeEvent.UnderlyingEvent is ScheduledExecution value)) { return; } this.logger?.LogInformation($"Genesis event in base universe rule occuring for rule {this.name} | event/universe time {universeEvent.EventTime} | correlation id {value.CorrelationId} | time series initiation {value.TimeSeriesInitiation} | time series termination {value.TimeSeriesTermination}"); this.Schedule = value; this.UniverseDateTime = universeEvent.EventTime; this.Genesis(); }
/// <summary> /// The filter on market intraday tick. /// </summary> /// <param name="value"> /// The value. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> private bool FilterOnMarketIntradayTick(IUniverseEvent value) { var exchFrame = (EquityIntraDayTimeBarCollection)value.UnderlyingEvent; if (exchFrame == null) { return(false); } if (this.markets.Type == RuleFilterType.Include) { if (exchFrame?.Exchange?.MarketIdentifierCode == null) { return(true); } var filter = !this.markets.Ids.Contains( exchFrame.Exchange.MarketIdentifierCode, StringComparer.InvariantCultureIgnoreCase); if (filter) { this.logger.LogInformation( $"filtering out stock tick with id {exchFrame.Exchange.MarketIdentifierCode} at {exchFrame.Epoch}"); } return(filter); } if (this.markets.Type == RuleFilterType.Exclude) { if (exchFrame?.Exchange?.MarketIdentifierCode == null) { return(false); } var filter = this.markets.Ids.Contains( exchFrame.Exchange.MarketIdentifierCode, StringComparer.InvariantCultureIgnoreCase); if (filter) { this.logger.LogInformation( $"filtering out stock tick with id {exchFrame.Exchange.MarketIdentifierCode} at {exchFrame.Epoch}"); } return(filter); } return(false); }
/// <summary> /// The on next. /// </summary> /// <param name="value"> /// The value. /// </param> public void OnNext(IUniverseEvent value) { if (!this.landmarks.Any()) { return; } var topOfStack = this.landmarks.Peek(); if (value.EventTime >= topOfStack.LandMark) { this.logger.LogInformation(topOfStack.LogMessage); this.landmarks.Pop(); } }
/// <summary> /// The trader factor. /// </summary> /// <param name="value"> /// The value. /// </param> private void TraderFactor(IUniverseEvent value) { var data = (Order)value.UnderlyingEvent; if (data == null) { return; } if (string.IsNullOrWhiteSpace(data.OrderTraderId) && !this.aggregateNonFactorableIntoOwnCategory) { return; } lock (this.traderLock) { var orderTraderId = data.OrderTraderId; if (string.IsNullOrWhiteSpace(orderTraderId)) { orderTraderId = string.Empty; } if (!this.traderFactors.ContainsKey(orderTraderId)) { var kvp = new KeyValuePair <string, IUniverseRule>( orderTraderId, this.cloneSource.Clone(new FactorValue(ClientOrganisationalFactors.Trader, orderTraderId))); this.traderFactors.Add(kvp); } if (this.traderFactors.ContainsKey(orderTraderId)) { this.traderFactors.TryGetValue(orderTraderId, out var rule); this.logger.LogInformation( $"has a trader organisational factor and found a rule for order trader id {orderTraderId}. Brokering."); rule?.OnNext(value); } else { this.logger.LogInformation( $"has a trader organisational factor but could not find a factored rule to pass onto for trader {orderTraderId}. Not brokering."); } } }
/// <summary> /// The strategy factor. /// </summary> /// <param name="value"> /// The value. /// </param> private void StrategyFactor(IUniverseEvent value) { var data = (Order)value.UnderlyingEvent; if (data == null) { return; } if (string.IsNullOrWhiteSpace(data.OrderStrategy) && !this.aggregateNonFactorableIntoOwnCategory) { return; } lock (this.strategyLock) { var orderStrategy = data.OrderStrategy; if (string.IsNullOrWhiteSpace(orderStrategy)) { orderStrategy = string.Empty; } if (!this.strategyFactors.ContainsKey(orderStrategy)) { var kvp = new KeyValuePair <string, IUniverseRule>( orderStrategy, this.cloneSource.Clone(new FactorValue(ClientOrganisationalFactors.Strategy, orderStrategy))); this.strategyFactors.Add(kvp); } if (this.strategyFactors.ContainsKey(orderStrategy)) { this.logger.LogInformation( $"has a strategy organisational factor and found a rule for strategy {orderStrategy}"); this.strategyFactors.TryGetValue(orderStrategy, out var rule); rule?.OnNext(value); } else { this.logger.LogInformation( $"has a strategy organisational factor and could not find a rule for strategy {orderStrategy}"); } } }
/// <summary> /// The on next event trigger /// </summary> /// <param name="value"> /// universe event to progress /// </param> public void OnNext(IUniverseEvent value) { this.logger.LogInformation( $"OnNext() event received at {value.EventTime}. Passing onto high profit and high profit market close rules."); // if removing the market closure rule // ensure that the alert subscriber is also updated to remove expectation of 2x flush events if (this.fixedIncomeParameters.PerformHighProfitWindowAnalysis) { this.streamRule.OnNext(value); this.marketClosureRule.OnNext(value); } if (this.fixedIncomeParameters.PerformHighProfitDailyAnalysis && !this.fixedIncomeParameters.PerformHighProfitWindowAnalysis) { this.marketClosureRule.OnNext(value); } }
/// <summary> /// The trade submitted delay. /// </summary> /// <param name="universeEvent"> /// The universe event. /// </param> private void TradeSubmittedDelay(IUniverseEvent universeEvent) { if (!(universeEvent.UnderlyingEvent is Order value)) { return; } this.logger?.LogTrace($"Trade placed event (delay) in base universe rule occuring for {this.name} | event/universe time {universeEvent.EventTime} | reddeer order id (p key) {value.ReddeerOrderId} | placed on {value.PlacedDate}"); this.UniverseDateTime = universeEvent.EventTime; var updatedHistory = this.UpdateTradeSubmittedTradingHistories( value, this.DelayedTradingInitialHistory, this.TradeBackwardWindowSize, this.ForwardWindowSize); this.RunInitialSubmissionEventDelayed(updatedHistory); }
/// <summary> /// The trade delay. /// </summary> /// <param name="universeEvent"> /// The universe event. /// </param> private void TradeDelay(IUniverseEvent universeEvent) { if (!(universeEvent.UnderlyingEvent is Order value)) { return; } this.logger?.LogTrace($"Trade event (status changed delayed) in base universe rule occuring for {this.name} | event/universe time {universeEvent.EventTime} | reddeer order id (p key){value.ReddeerOrderId}"); this.UniverseDateTime = universeEvent.EventTime; var updatedHistory = this.UpdateTradeLatestTradingHistories( value, this.DelayedTradingHistory, this.TradeBackwardWindowSize, this.ForwardWindowSize); this.RunPostOrderEventDelayed(updatedHistory); }
private void MarketOpen(IUniverseEvent value) { this.Analytics.StockMarketOpenCount += 1; var marketFrame = (MarketOpenClose)value.UnderlyingEvent; if (string.IsNullOrWhiteSpace(marketFrame?.MarketId)) { return; } lock (this._marketIdLock) { if (!this._marketIds.ContainsKey(marketFrame.MarketId?.ToLower())) { this._marketIds.Add( new KeyValuePair <string, string>(marketFrame.MarketId.ToLower(), marketFrame.MarketId)); } } }
public void OnNext(IUniverseEvent value) { if (value == null) { this._logger.LogWarning("received a null analytics stream event."); return; } this._logger.LogInformation( $"received an analytics event of type {value.StateChange} at {value.EventTime} universe time."); switch (value.StateChange) { case UniverseStateEvent.Genesis: this.Analytics.GenesisEventCount += 1; break; case UniverseStateEvent.Eschaton: this.Eschaton(); break; case UniverseStateEvent.ExchangeClose: this.Analytics.StockMarketCloseCount += 1; break; case UniverseStateEvent.ExchangeOpen: this.MarketOpen(value); break; case UniverseStateEvent.EquityIntraDayTick: this.StockTick(value); break; case UniverseStateEvent.Order: this.TradeUpdate(value); break; case UniverseStateEvent.OrderPlaced: this.Analytics.TradeReddeerSubmittedCount += 1; break; } }
/// <summary> /// The filter on markets. /// </summary> /// <param name="value"> /// The value. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> private bool FilterOnMarkets(IUniverseEvent value) { if (this.markets == null) { return(false); } if (this.markets.Type == RuleFilterType.None) { return(false); } if (value == null) { return(false); } if (value.StateChange != UniverseStateEvent.Order && value.StateChange != UniverseStateEvent.OrderPlaced && value.StateChange != UniverseStateEvent.EquityIntraDayTick) { return(false); } if (value.StateChange == UniverseStateEvent.EquityIntraDayTick) { return(this.FilterOnMarketIntradayTick(value)); } if (value.StateChange == UniverseStateEvent.Order || value.StateChange == UniverseStateEvent.OrderPlaced) { return(this.FilterOnOrderAttribute( value, this.markets, i => i?.Market?.MarketIdentifierCode, "market")); } return(false); }
/// <summary> /// The on next. /// </summary> /// <param name="value"> /// The value. /// </param> public void OnNext(IUniverseEvent value) { if (value == null) { return; } if (!this.list.Any()) { return; } var match = this.list.FirstOrDefault(m => ReferenceEquals(m.Events, value)); if (match == null) { return; } this.logger.LogInformation(match?.LogMessage); this.list.Remove(match); }
private void TradeUpdate(IUniverseEvent value) { this.Analytics.TradeReddeerCount += 1; var tradeFrame = (Order)value.UnderlyingEvent; if (tradeFrame.DealerOrders == null || !tradeFrame.DealerOrders.Any()) { return; } lock (this._traderIdLock) { foreach (var trade in tradeFrame.DealerOrders.Where(tf => tf != null).ToList()) { if (!this._traderIds.ContainsKey(trade.DealerId.ToLower())) { this._traderIds.Add( new KeyValuePair <string, string>(trade.DealerId.ToLower(), trade.DealerId.ToLower())); } } } }
/// <summary> /// The filter on traders. /// </summary> /// <param name="value"> /// The value. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> private bool FilterOnTraders(IUniverseEvent value) { return(this.FilterOnOrderAttribute(value, this.traders, i => i.OrderTraderId, "Trader")); }
/// <summary> /// The filter. /// </summary> /// <param name="value"> /// The value. /// </param> /// <returns> /// The <see cref="IUniverseEvent"/>. /// </returns> protected override IUniverseEvent Filter(IUniverseEvent value) { return(this.orderFilter.Filter(value)); }
/// <summary> /// Initializes a new instance of the <see cref="PercentageLandMark"/> class. /// </summary> /// <param name="events"> /// The events. /// </param> /// <param name="logMessage"> /// The log message. /// </param> public PercentageLandMark(IUniverseEvent events, string logMessage) { this.Events = events; this.LogMessage = logMessage ?? string.Empty; }