/// <summary>
/// This version of the call requests hourly chunks
/// </summary>
/// <param name="alertFilter"></param>
/// <param name="chunkSize"></param>
public async Task <List <Alert> > GetRestAlertsWithV84Bug(AlertFilter alertFilter, TimeSpan chunkSize)
{
var originalStartEpochIsAfter = alertFilter.StartEpochIsAfter;
var originalStartEpochIsBefore = alertFilter.StartEpochIsBefore;
var utcNow = DateTime.UtcNow;
if (alertFilter.StartEpochIsAfter == null)
{
alertFilter.StartEpochIsAfter = utcNow.AddYears(-1).SecondsSinceTheEpoch();
}
if (alertFilter.StartEpochIsBefore == null)
{
alertFilter.StartEpochIsBefore = utcNow.SecondsSinceTheEpoch();
}
var allAlerts = new ConcurrentBag <Alert>();
var alertFilterList = ((long)alertFilter.StartEpochIsAfter).ToDateTimeUtc()
.GetChunkedTimeRangeList(((long)alertFilter.StartEpochIsBefore).ToDateTimeUtc(), chunkSize)
.Select(t =>
{
var newAlertFilter = alertFilter.Clone();
newAlertFilter.ResetSearch();
newAlertFilter.StartEpochIsAfter = t.Item1.SecondsSinceTheEpoch() - 1; // Take one off to include anything raised on that exact second
newAlertFilter.StartEpochIsBefore = t.Item2.SecondsSinceTheEpoch();
return(newAlertFilter);
});
await Task.WhenAll(alertFilterList.Select(async individualAlertFilter =>
{
foreach (var alert in await GetRestAlertsWithoutV84BugAsync(individualAlertFilter).ConfigureAwait(false))
{
allAlerts.Add(alert);
}
})).ConfigureAwait(false);
alertFilter.StartEpochIsAfter = originalStartEpochIsAfter;
alertFilter.StartEpochIsBefore = originalStartEpochIsBefore;
return(allAlerts.DistinctBy(a => a.Id).Take(alertFilter.Take ?? int.MaxValue).ToList());
}
public async Task <Response> CreateResponseAsync()
{
ConcurrentBag <UserVm> foundUsers = new ConcurrentBag <UserVm>();
ConcurrentBag <ChannelVm> foundChannels = new ConcurrentBag <ChannelVm>();
ConcurrentBag <ChatVm> foundChats = new ConcurrentBag <ChatVm>();
var nodesInfo = await nodesService.GetAllNodesInfoAsync().ConfigureAwait(false);
List <Task> searchTasks = new List <Task>();
foreach (var node in nodesInfo)
{
Task task = Task.Run(async() =>
{
var nodeConnection = connectionsService.GetNodeConnection(node.Id);
if (nodeConnection != null)
{
SearchNodeResponse searchNodeResponse = await nodeRequestSender.GetSearchResponseAsync(
request.SearchQuery, request.NavigationId, request.Direction, request.SearchTypes, clientConnection.UserId, nodeConnection).ConfigureAwait(false);
if (searchNodeResponse?.Users != null)
{
foundUsers.AddRange(searchNodeResponse.Users);
}
if (searchNodeResponse?.Chats != null)
{
foundChats.AddRange(searchNodeResponse.Chats);
}
if (searchNodeResponse?.Channels != null)
{
foundChannels.AddRange(searchNodeResponse.Channels);
}
await MetricsHelper.Instance.SetCrossNodeApiInvolvedAsync(request.RequestId).ConfigureAwait(false);
}
else if (NodeSettings.Configs.Node.Id == node.Id)
{
foreach (var searchType in request.SearchTypes.Distinct())
{
switch (searchType)
{
case SearchType.Users:
{
List <UserVm> users = await loadUsersService.FindUsersByStringQueryAsync(
request.SearchQuery,
request.NavigationId.GetValueOrDefault(),
request.Direction.GetValueOrDefault(true)).ConfigureAwait(false);
foundUsers.AddRange(privacyService.ApplyPrivacySettings(users, request.SearchQuery, clientConnection.UserId));
}
break;
case SearchType.Chats:
{
List <ChatVm> chats = await loadChatsService.FindChatsByStringQueryAsync(
request.SearchQuery,
request.NavigationId.GetValueOrDefault(),
request.Direction.GetValueOrDefault(true),
clientConnection.UserId).ConfigureAwait(false);
foundChats.AddRange(chats);
}
break;
case SearchType.Channels:
{
List <ChannelVm> channels = await loadChannelsService.FindChannelsByStringQueryAsync(
request.SearchQuery,
request.NavigationId.GetValueOrDefault(),
request.Direction.GetValueOrDefault(true)).ConfigureAwait(false);
foundChannels.AddRange(channels);
}
break;
default:
continue;
}
}
}
});
searchTasks.Add(task);
}
await Task.WhenAll(searchTasks).ConfigureAwait(false);
foundChats = new ConcurrentBag <ChatVm>(foundChats.DistinctBy(opt => opt.Id));
foundChannels = new ConcurrentBag <ChannelVm>(foundChannels.DistinctBy(opt => opt.ChannelId));
return(new SearchResponse(request.RequestId,
request.Direction.GetValueOrDefault(true) ? foundUsers.OrderBy(opt => opt.Id) : foundUsers.OrderByDescending(opt => opt.Id),
request.Direction.GetValueOrDefault(true) ? foundChats.OrderBy(opt => opt.Id) : foundChats.OrderByDescending(opt => opt.Id),
request.Direction.GetValueOrDefault(true) ? foundChannels.OrderBy(opt => opt.ChannelId) : foundChannels.OrderByDescending(opt => opt.ChannelId)));
}
