public async Task Execute(string messageId, string messageBody)
{
this._logger.LogInformation(
$"{nameof(DataRequestSubscriber)} about to process a message with id of {messageId}");
var opCtx = this._systemProcessContext.CreateAndStartOperationContext();
ISystemProcessOperationThirdPartyDataRequestContext dataCtx = null;
try
{
var request = this._serialiser.Deserialise(messageBody);
dataCtx = opCtx.CreateAndStartDataRequestContext(messageId, request.SystemProcessOperationId);
if (!this.ValidateDataRequest(request.SystemProcessOperationId))
{
this._logger.LogError(
$"{nameof(DataRequestSubscriber)} received a null or empty system process operation id. Exiting");
return;
}
await this._dataRequestManager.Handle(request.SystemProcessOperationId, dataCtx);
}
catch (Exception e)
{
dataCtx?.EventError(e.Message);
}
finally
{
dataCtx?.EndEvent();
opCtx.EndEvent();
this._logger.LogInformation(
$"{nameof(DataRequestSubscriber)} completed processing a message with id of {messageId}");
}
}
public void Setup()
{
_tickPriceHistoryServiceClientFactory = A.Fake <ITickPriceHistoryServiceClientFactory>();
_refinitivTickPriceHistoryApiConfig = A.Fake <IRefinitivTickPriceHistoryApiConfig>();
_requestContext = A.Fake <ISystemProcessOperationThirdPartyDataRequestContext>();
_logger = A.Fake <ILogger <IRefinitivDataSynchroniser> >();
}
public void Setup()
{
this._dataRequestManager = A.Fake <IBmllDataRequestManager>();
this._filter = new BmllDataRequestFilter();
this._requestContext = A.Fake <ISystemProcessOperationThirdPartyDataRequestContext>();
this._logger = A.Fake <ILogger <BmllDataSynchroniser> >();
}
public void TearDown()
{
_tickPriceHistoryServiceClientFactory = null;
_refinitivTickPriceHistoryApiConfig = null;
_requestContext = null;
_logger = null;
}
public void Setup()
{
this._dataRequestsManager = A.Fake <IFactsetDataRequestsManager>();
this._requestFilter = A.Fake <IFactsetDataRequestFilter>();
A.CallTo(() => this._requestFilter.ValidAssetType(A <MarketDataRequest> .Ignored)).Returns(true);
this._requestContext = A.Fake <ISystemProcessOperationThirdPartyDataRequestContext>();
this._logger = A.Fake <ILogger <FactsetDataSynchroniser> >();
}
public async Task Handle(string systemProcessOperationId, ISystemProcessOperationThirdPartyDataRequestContext dataRequestContext, IReadOnlyCollection <MarketDataRequest> marketDataRequests)
{
if (marketDataRequests == null || !marketDataRequests.Any())
{
this._logger.LogError($"{nameof(RefinitivDataSynchroniser)} Handle received a null or empty market data request collection");
return;
}
var maxToDate = marketDataRequests.Select(a => a.UniverseEventTimeTo).Max();
var minFromDate = marketDataRequests.Select(a => a.UniverseEventTimeFrom).Min();
if (maxToDate != null && minFromDate != null)
{
var request = new GetEodPricingRequest
{
StartUtc = minFromDate.Value.ToUniversalTime().ToTimestamp(),
EndUtc = maxToDate.Value.ToUniversalTime().ToTimestamp(),
PollPeriod = _refinitivTickPriceHistoryApiConfig.RefinitivTickPriceHistoryApiPollingSeconds,
TimeOut = new Duration()
{
Seconds = _refinitivTickPriceHistoryApiConfig.RefinitivTickPriceHistoryApiTimeOutDurationSeconds
},
};
var ids = marketDataRequests.Select(req => new SecurityIdentifiers()
{
Ric = req.Identifiers.Ric,
Cusip = req.Identifiers.Cusip,
Isin = req.Identifiers.Isin,
Sedol = req.Identifiers.Sedol
});
request.Identifiers.AddRange(ids);
if (request.Identifiers.All(s => s.Ric == null))
{
this._logger.LogError($"{nameof(RefinitivDataSynchroniser)} Handle received a request that didn't have a RIC");
return;
}
this._logger.LogInformation($"{nameof(RefinitivDataSynchroniser)} Making request for the date range of {request.StartUtc} - {request.EndUtc} using the following RIC identifiers: " +
$"{string.Join(" ", request.Identifiers.Select(s => s.Ric).ToArray())}");
var tickPriceHistoryServiceClient = _tickPriceHistoryServiceClientFactory.Create();
await tickPriceHistoryServiceClient.GetEodPricingAsync(request);
this._logger.LogInformation($"{nameof(RefinitivDataSynchroniser)} Request returned for the date range of {request.StartUtc} - {request.EndUtc} using the following RIC identifiers: " +
$"{string.Join(" ", request.Identifiers.Select(s => s.Ric).ToArray())}");
}
else
{
this._logger.LogError($"{nameof(RefinitivDataSynchroniser)} Handle received a request collection with no dates");
return;
}
}
public void Setup()
{
this._bmllSynchroniser = A.Fake <IBmllDataSynchroniser>();
this._factsetSynchroniser = A.Fake <IFactsetDataSynchroniser>();
this._markitSynchroniser = A.Fake <IMarkitDataSynchroniser>();
this._dataRequestContext = A.Fake <ISystemProcessOperationThirdPartyDataRequestContext>();
this._scheduleRulePublisher = A.Fake <IScheduleRulePublisher>();
this._repository = A.Fake <IRuleRunDataRequestRepository>();
this._refinitivDataSynchroniser = A.Fake <IRefinitivDataSynchroniser>();
this._logger = A.Fake <ILogger <DataRequestManager> >();
}
public async Task Handle(
string systemProcessOperationId,
ISystemProcessOperationThirdPartyDataRequestContext dataRequestContext,
IReadOnlyCollection <MarketDataRequest> marketDataRequests)
{
this._logger.LogInformation($"{nameof(MarkitDataSynchroniser)} Handle processing request");
this._logger.LogInformation($"{nameof(MarkitDataSynchroniser)} Handle completed processing request");
await Task.CompletedTask;
}
public async Task Handle(
string systemProcessOperationId,
ISystemProcessOperationThirdPartyDataRequestContext dataRequestContext,
IReadOnlyCollection <MarketDataRequest> marketDataRequests)
{
this._logger.LogInformation(
$"{nameof(BmllDataSynchroniser)} Handle began processing a request for {nameof(systemProcessOperationId)} {systemProcessOperationId}");
if (string.IsNullOrWhiteSpace(systemProcessOperationId))
{
this._logger?.LogError(
$"{nameof(BmllDataSynchroniser)} Handle received a null or empty system process operation id returning");
return;
}
if (dataRequestContext == null)
{
this._logger?.LogError(
$"{nameof(BmllDataSynchroniser)} Handle received a null data request context returning");
return;
}
if (marketDataRequests == null || !marketDataRequests.Any())
{
this._logger?.LogError(
$"{nameof(BmllDataSynchroniser)} Handle received a null or empty market data requests collection");
return;
}
var filteredMarketDataRequests = marketDataRequests.Where(this._filter.ValidAssetType).ToList();
if (!filteredMarketDataRequests.Any())
{
this._logger?.LogInformation(
$"{nameof(BmllDataSynchroniser)} Handle received a null or empty market data requests collection");
return;
}
await this._requestManager.Submit(systemProcessOperationId, filteredMarketDataRequests);
this._logger.LogInformation($"{nameof(BmllDataSynchroniser)} Handle completed processing a request");
}
public async Task Handle(
string systemProcessOperationId,
ISystemProcessOperationThirdPartyDataRequestContext dataRequestContext,
IReadOnlyCollection <MarketDataRequest> marketDataRequests)
{
if (string.IsNullOrWhiteSpace(systemProcessOperationId))
{
this._logger.LogError(
$"{nameof(FactsetDataSynchroniser)} Handle received a null or empty system process operation id");
return;
}
if (dataRequestContext == null)
{
this._logger.LogError($"{nameof(FactsetDataSynchroniser)} Handle received a null data request context");
return;
}
if (marketDataRequests == null || !marketDataRequests.Any())
{
this._logger.LogError(
$"{nameof(FactsetDataSynchroniser)} Handle received a null or empty market data request collection");
return;
}
var filteredMarketDataRequests = marketDataRequests.Where(this._requestFilter.ValidAssetType).ToList();
if (!filteredMarketDataRequests.Any())
{
this._logger.LogInformation(
$"{nameof(FactsetDataSynchroniser)} Handle received market data requests but none passed the data request filter (equity CFI)");
return;
}
await this._factsetDataRequestsManager.Submit(filteredMarketDataRequests, systemProcessOperationId);
}
public async Task Handle(
string systemProcessOperationId,
ISystemProcessOperationThirdPartyDataRequestContext dataRequestContext)
{
if (string.IsNullOrWhiteSpace(systemProcessOperationId))
{
this._logger.LogError(
$"{nameof(DataRequestManager)} asked to handle a systemProcessOperationId that had a null or empty id");
dataRequestContext.EventError("DataRequestManager systemProcessOperationId was null");
return;
}
this._logger.LogInformation(
$"{nameof(DataRequestManager)} handling request with id {systemProcessOperationId}");
var dataRequests =
await this._dataRequestRepository.DataRequestsForSystemOperation(systemProcessOperationId);
dataRequests = dataRequests ?? new List <MarketDataRequest>();
this._logger.LogInformation(
$"handling request with id {systemProcessOperationId} had {dataRequests.Count} data requests to process across all data sources");
try
{
// Equity handling
var factsetData = dataRequests.Where(
_ => _.DataSource == DataSource.Factset || _.DataSource == DataSource.Any ||
_.DataSource == DataSource.AnyInterday).ToList();
this._logger.LogInformation(
$"handling request with id {systemProcessOperationId} had {factsetData.Count} factset data requests to process");
if (factsetData.Any())
{
await this._factsetSynchroniser.Handle(systemProcessOperationId, dataRequestContext, factsetData);
}
var bmllData = dataRequests.Where(
_ => _.DataSource == DataSource.Bmll || _.DataSource == DataSource.Any ||
_.DataSource == DataSource.AnyIntraday).ToList();
this._logger.LogInformation(
$"handling request with id {systemProcessOperationId} had {bmllData.Count} bmll data requests to process");
if (bmllData.Any())
{
await this._bmllSynchroniser.Handle(systemProcessOperationId, dataRequestContext, bmllData);
}
// Fixed income handling
var refinitivInterdayData = dataRequests.Where(_ => _.DataSource == DataSource.RefinitivInterday).ToList();
this._logger.LogInformation($"handling request with id {systemProcessOperationId} had {refinitivInterdayData.Count} refinitiv data requests to process");
if (refinitivInterdayData.Any())
{
await this._refinitivDataSynchroniser.Handle(systemProcessOperationId, dataRequestContext, refinitivInterdayData);
}
var markitData = dataRequests.Where(
_ => _.DataSource == DataSource.Markit || _.DataSource == DataSource.Any ||
_.DataSource == DataSource.AnyInterday ||
_.DataSource == DataSource.AnyIntraday).ToList();
this._logger.LogInformation(
$"handling request with id {systemProcessOperationId} had {markitData.Count} markit data requests to process");
if (markitData.Any())
{
await this._markitSynchroniser.Handle(systemProcessOperationId, dataRequestContext, markitData);
}
}
finally
{
if (dataRequests != null && dataRequests.Any())
{
await this._rulePublisher.RescheduleRuleRun(systemProcessOperationId, dataRequests);
}
this._logger.LogInformation(
$"{nameof(DataRequestManager)} completed handling request with id {systemProcessOperationId}");
}
}
