/// <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;
}
