public async Task <List <LivestreamQueryResult> > GetTopStreams(TopStreamQuery topStreamQuery)
{
if (topStreamQuery == null)
{
throw new ArgumentNullException(nameof(topStreamQuery));
}
var query = new GetStreamsQuery()
{
First = topStreamQuery.Take
};
if (!string.IsNullOrWhiteSpace(topStreamQuery.GameName))
{
var gameId = await GetGameIdByName(topStreamQuery.GameName);
query.GameIds.Add(gameId);
}
var topStreams = await twitchTvHelixClient.GetStreams(query);
return(topStreams.Select(x =>
{
var channelIdentifier = new ChannelIdentifier(this, x.UserId)
{
DisplayName = x.UserName
};
var queryResult = new LivestreamQueryResult(channelIdentifier);
var livestreamModel = new LivestreamModel(x.UserId, channelIdentifier);
livestreamModel.PopulateWithStreamDetails(x);
queryResult.LivestreamModel = livestreamModel;
return queryResult;
}).ToList());
}
/// <summary> Gets the top streams </summary>
public async Task<List<Stream>> GetTopStreams(TopStreamQuery topStreamQuery, CancellationToken cancellationToken = default(CancellationToken))
{
if (topStreamQuery == null) throw new ArgumentNullException(nameof(topStreamQuery));
var request = $"{RequestConstants.Streams}?offset={topStreamQuery.Skip}&limit={topStreamQuery.Take}";
if (!String.IsNullOrWhiteSpace(topStreamQuery.GameName))
request += $"&game={topStreamQuery.GameName}";
var streamRoot = await ExecuteRequest<StreamsRoot>(request, cancellationToken);
return streamRoot.Streams;
}
private async Task <HashSet <LivestreamModel> > GetPopularStreams()
{
const int maxReturnCount = 5;
var popularStreams = new HashSet <LivestreamModel>();
int requeries = 0;
try
{
var supportApiClients = apiClientFactory.GetAll().Where(x => x.HasTopStreamsSupport).ToList();
while (popularStreams.Count < maxReturnCount && requeries < 3)
{
var topStreamsQuery = new TopStreamQuery()
{
Skip = requeries * maxReturnCount, Take = maxReturnCount
};
var possibleStreams = new List <LivestreamModel>();
foreach (var apiClient in supportApiClients)
{
var queryResults = await apiClient.GetTopStreams(topStreamsQuery);
possibleStreams.AddRange(queryResults.Where(x => x.IsSuccess).Select(x => x.LivestreamModel));
}
// perform this check before further filtering since this is the most important check
if (possibleStreams.All(x => x.Viewers < MinimumEventViewers))
{
break;
}
popularStreams.UnionWith(
possibleStreams.Where(x =>
x.Viewers >= MinimumEventViewers &&
!ExcludedGames.Contains(x.Game) &&
!notifiedEvents.Contains(x.UniqueStreamKey.ToString())
));
requeries++;
}
}
catch
{
// nothing we can really do here, we just wanna make sure the polling continues
}
return(popularStreams);
}
public async Task GetTopStreams(string gameName)
{
var topStreamsQuery = new TopStreamQuery()
{
Skip = 0, Take = 100, GameName = gameName
};
var topStreams = await sut.GetTopStreams(topStreamsQuery);
Assert.NotNull(topStreams);
Assert.NotEmpty(topStreams);
if (topStreamsQuery.GameName != null)
{
Assert.All(topStreams, stream => Assert.Contains(topStreamsQuery.GameName, stream.Game, StringComparison.OrdinalIgnoreCase));
}
}
public async Task <List <LivestreamQueryResult> > GetTopStreams(TopStreamQuery topStreamQuery)
{
var hitboxTopStreamQuery = new ExternalAPIs.Hitbox.Query.TopStreamsQuery()
{
GameName = topStreamQuery.GameName
};
var topStreams = await hitboxClient.GetTopStreams(hitboxTopStreamQuery);
if (topStreams == null)
{
return(new List <LivestreamQueryResult>());
}
return(topStreams.ConvertAll(ConvertToLivestreamModel)
.Select(x => new LivestreamQueryResult(new ChannelIdentifier(this, x.Id))
{
LivestreamModel = x,
}).ToList());
}
public async Task <List <LivestreamQueryResult> > GetTopStreams(TopStreamQuery topStreamQuery)
{
var pagedQuery = new BeamProPagedQuery()
{
Skip = topStreamQuery.Skip,
Take = topStreamQuery.Take
};
var topStreams = await beamProClient.GetTopStreams(pagedQuery);
return(topStreams.ConvertAll(input =>
{
var channelIdentifier = new ChannelIdentifier(this, input.token);
channelNameIdMap[input.token] = input.id;
return new LivestreamQueryResult(channelIdentifier)
{
LivestreamModel = ConvertToLivestreamModel(input)
};
}));
}
// Makes sure the items collection is populated with items for the current page
private async Task EnsureItems()
{
if (!IsActive)
{
return;
}
LoadingItems = true;
try
{
Items.Clear();
var topStreamsQuery = new TopStreamQuery
{
GameName = GameName,
Skip = (Page - 1) * ItemsPerPage,
Take = ItemsPerPage,
};
var topStreams = await SelectedApiClient.GetTopStreams(topStreamsQuery);
var monitoredStreams = monitorStreamsModel.Livestreams;
var topStreamResults = new List <TopStreamResult>();
foreach (var topLivestream in topStreams)
{
var topStreamResult = new TopStreamResult(topLivestream.LivestreamModel, topLivestream.ChannelIdentifier);
topStreamResult.IsMonitored = monitoredStreams.Any(x => Equals(x, topLivestream.LivestreamModel));
topStreamResult.LivestreamModel.SetLivestreamNotifyState(settingsHandler.Settings);
topStreamResults.Add(topStreamResult);
}
Items.AddRange(topStreamResults);
}
catch (Exception ex)
{
await this.ShowMessageAsync("Error",
$"Error getting top streams from '{SelectedApiClient.ApiName}'.{Environment.NewLine}{Environment.NewLine}{ex}");
}
LoadingItems = false;
}
public async Task <List <LivestreamQueryResult> > GetTopStreams(TopStreamQuery topStreamQuery)
{
if (topStreamQuery == null)
{
throw new ArgumentNullException(nameof(topStreamQuery));
}
var topStreams = await twitchTvClient.GetTopStreams(topStreamQuery);
return(topStreams.Select(x =>
{
var channelIdentifier = new ChannelIdentifier(this, x.Channel.Name);
var queryResult = new LivestreamQueryResult(channelIdentifier);
var livestreamModel = new LivestreamModel(x.Channel?.Name, channelIdentifier);
livestreamModel.PopulateWithStreamDetails(x);
livestreamModel.PopulateWithChannel(x.Channel);
queryResult.LivestreamModel = livestreamModel;
return queryResult;
}).ToList());
}
public Task <List <LivestreamQueryResult> > GetTopStreams(TopStreamQuery topStreamQuery)
{
throw new NotImplementedException();
}
