public async Task RefreshLivestreams()
{
try
{
await MonitorStreamsModel.RefreshLivestreams();
}
catch (AggregateException aggregateException)
{
foreach (var ex in aggregateException.InnerExceptions)
{
var messageDialogResult = await this.ShowMessageAsync(
"Error refreshing livestreams", ex.ExtractErrorMessage(),
MessageDialogStyle.AffirmativeAndNegative,
new MetroDialogSettings()
{
NegativeButtonText = "Ignore"
});
if (messageDialogResult == MessageDialogResult.Negative)
{
MonitorStreamsModel.IgnoreQueryFailure(ex.Message);
}
}
}
catch (Exception ex)
{
await this.ShowMessageAsync("Error refreshing livestreams", ex.ExtractErrorMessage());
}
}
private void MonitorStreamsModelOnPropertyChanged(object sender, PropertyChangedEventArgs e)
{
if (e.PropertyName == nameof(MonitorStreamsModel.CanRefreshLivestreams))
{
CanRefreshLivestreams = MonitorStreamsModel.CanRefreshLivestreams;
}
else if (e.PropertyName == nameof(MonitorStreamsModel.SelectedLivestream) || e.PropertyName == nameof(MonitorStreamsModel.CanOpenStream))
{
var selectedLivestream = MonitorStreamsModel.SelectedLivestream;
CanOpenChat = selectedLivestream != null && selectedLivestream.ApiClient.HasChatSupport;
// would like a nicer way of resetting the stream qualities when changing selected streams or the currently selected stream changes between offline/online
StreamQualities.Clear();
if (MonitorStreamsModel.CanOpenStream)
{
if (selectedLivestream.IsPartner) // twitch partner specific
{
StreamQualities.AddRange(Enum.GetNames(typeof(StreamQuality)));
}
else
{
StreamQualities.AddRange(new[] { StreamQuality.Best.ToString(), StreamQuality.Worst.ToString(), });
}
MonitorStreamsModel.SetDefaultSelectedStreamQuality();
}
}
}
public async Task AddStream()
{
if (IsNullOrWhiteSpace(StreamName) || !CanAddStream)
{
return;
}
CanAddStream = false;
var dialogController = await this.ShowProgressAsync("Adding stream", $"Adding new stream '{StreamName}'");
try
{
await MonitorStreamsModel.AddLivestream(new ChannelIdentifier(SelectedApiClient, StreamName), this);
StreamName = null;
await dialogController.CloseAsync();
}
catch (Exception ex)
{
CanAddStream = true; // on failure streamname not cleared so the user can try adding again
await dialogController.CloseAsync();
var httpException = ex.InnerException as HttpRequestWithStatusException;
if (httpException != null && httpException.StatusCode == HttpStatusCode.NotFound)
{
await this.ShowMessageAsync("Error adding stream.",
$"No channel found named '{StreamName}' for stream provider {SelectedApiClient.ApiName}{Environment.NewLine}" +
$"{Environment.NewLine}{TIP_ERROR_ADD_STREAM}");
}
else
{
await this.ShowMessageAsync("Error adding stream.", $"{ex.Message}{Environment.NewLine}{TIP_ERROR_ADD_STREAM}");
}
}
}
public async Task RefreshLivestreams()
{
try
{
await MonitorStreamsModel.RefreshLivestreams();
}
catch (AggregateException ex)
{
await this.ShowMessageAsync("Error refreshing livestreams", ex.Flatten().ExtractErrorMessage());
}
catch (Exception ex)
{
await this.ShowMessageAsync("Error refreshing livestreams", ex.ExtractErrorMessage());
}
}
public async Task ImportFollows()
{
if (!SelectedApiClient.HasUserFollowQuerySupport)
{
await this.ShowMessageAsync("No import support",
$"{SelectedApiClient.ApiName} does not have support for importing followed streams");
return;
}
var dialogSettings = new MetroDialogSettings()
{
AffirmativeButtonText = "Import"
};
var username = await this.ShowDialogAsync("Import Streams",
$"Enter username for importing followed streams from '{SelectedApiClient.ApiName}'",
dialogSettings);
if (!IsNullOrWhiteSpace(username))
{
username = username.Trim();
var dialogController = await this.ShowProgressAsync("Importing followed streams", $"Importing followed streams from '{SelectedApiClient.ApiName}' for username '{username}'");
try
{
await MonitorStreamsModel.ImportFollows(username, SelectedApiClient);
}
catch (Exception ex)
{
await dialogController.CloseAsync();
await this.ShowMessageAsync("Error importing channels", ex.Message);
// TODO log import error
}
await dialogController.CloseAsync();
}
}
