public async Task GetEpisodeDetails()
{
if (_navService.IsNetworkAvailable)
{
if (SelectedEpisode != null && Episodes.IsNullOrEmpty())
{
SetProgressBar(AppResources.SysTrayGettingEpisodeDetails);
try
{
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
ParentId = SelectedEpisode.ParentId,
Fields = new[]
{
ItemFields.ParentId,
ItemFields.Overview
}
};
//Log.Info("Getting episodes for Season [{0}] ({1}) of TV Show [{2}] ({3})", SelectedSeason.Name, SelectedSeason.Id, SelectedTvSeries.Name, SelectedTvSeries.Id);
var episodes = await _apiClient.GetItemsAsync(query);
Episodes = episodes.Items.OrderBy(x => x.IndexNumber).ToList();
}
catch (HttpException ex)
{
}
SetProgressBar();
}
}
}
public async Task GetEpisodeDetails()
{
if (NavigationService.IsNetworkAvailable)
{
var index = SelectedEpisode.IndexNumber;
if (SelectedEpisode != null && Episodes.IsNullOrEmpty())
{
SetProgressBar(AppResources.SysTrayGettingEpisodeDetails);
try
{
if (string.IsNullOrEmpty(SelectedEpisode.SeriesId))
{
var episode = await ApiClient.GetItemAsync(SelectedEpisode.Id, AuthenticationService.Current.LoggedInUserId);
if (episode == null)
{
await _messageBox.ShowAsync(AppResources.ErrorEpisodeDetails);
NavigationService.GoBack();
return;
}
SelectedEpisode = episode;
}
var query = new EpisodeQuery
{
UserId = AuthenticationService.Current.LoggedInUserId,
SeasonId = SelectedEpisode.SeasonId,
SeriesId = SelectedEpisode.SeriesId,
Fields = new[]
{
ItemFields.ParentId,
ItemFields.Overview,
ItemFields.MediaSources,
}
};
//Log.Info("Getting episodes for Season [{0}] ({1}) of TV Show [{2}] ({3})", SelectedSeason.Name, SelectedSeason.Id, SelectedTvSeries.Name, SelectedTvSeries.Id);
var episodes = await ApiClient.GetEpisodesAsync(query);
Episodes = episodes.Items.OrderBy(x => x.IndexNumber).ToList();
}
catch (HttpException ex)
{
Utils.HandleHttpException("GetEpisodeDetails()", ex, NavigationService, Log);
}
SetProgressBar();
}
if (SelectedEpisode != null)
{
SelectedEpisode = Episodes.FirstOrDefault(x => x.IndexNumber == index);
CanResume = SelectedEpisode != null && SelectedEpisode.CanResume;
}
}
}
public override void WireMessages()
{
Messenger.Default.Register <NotificationMessage>(this, m =>
{
if (m.Notification.Equals(Constants.Messages.ClearEpisodesMsg))
{
Episodes.Clear();
}
if (m.Notification.Equals(Constants.Messages.RefreshResumeMsg))
{
var id = (string)m.Sender;
var ticks = (long)m.Target;
if (id == SelectedEpisode.Id)
{
if (SelectedEpisode.UserData == null)
{
SelectedEpisode.UserData = new UserItemDataDto();
}
SelectedEpisode.UserData.PlaybackPositionTicks = ticks;
SelectedEpisode.HasPlayed();
CanResume = SelectedEpisode.CanResume;
}
}
});
Messenger.Default.Register <SyncNotificationMessage>(this, m =>
{
if (m.Notification.Equals(Constants.Messages.SyncJobFinishedMsg))
{
switch (m.ItemType.ToLower())
{
case "episode":
if (SelectedEpisode != null && SelectedEpisode.Id == m.ItemId)
{
SelectedEpisode.IsSynced = true;
}
if (!Episodes.IsNullOrEmpty())
{
var episode = Episodes.FirstOrDefault(x => x.Id == m.ItemId);
if (episode != null)
{
episode.IsSynced = true;
}
}
break;
case "season":
if (SelectedSeason != null)
{
SelectedSeason.IsSynced = true;
}
if (!Seasons.IsNullOrEmpty())
{
var season = Seasons.FirstOrDefault(x => x.Id == m.ItemId);
if (season != null)
{
season.IsSynced = true;
}
}
break;
case "series":
if (SelectedTvSeries != null)
{
SelectedTvSeries.IsSynced = true;
}
break;
}
}
});
}
private void WireCommands()
{
TvSeriesPageLoaded = new RelayCommand(async() =>
{
DummyFolder = new BaseItemDto
{
Type = "folder",
Name = string.Format(AppResources.TvShowRecentItemsTitle, SelectedTvSeries.Name.ToLower()),
Id = SelectedTvSeries.Id
};
if (NavigationService.IsNetworkAvailable && !ShowDataLoaded)
{
if (SelectedTvSeries != null)
{
SetProgressBar(AppResources.SysTrayGettingShowInformation);
try
{
Log.Info("Getting information for TV Series [{0}] ({1})", SelectedTvSeries.Name, SelectedTvSeries.Id);
SelectedTvSeries = await ApiClient.GetItemAsync(SelectedTvSeries.Id, AuthenticationService.Current.LoggedInUserId);
CastAndCrew = Utils.GroupCastAndCrew(SelectedTvSeries.People);
}
catch (HttpException ex)
{
if (Utils.HandleHttpException("TvSeriesPageLoaded", ex, NavigationService, Log))
{
SetProgressBar();
return;
}
}
bool seasonsLoaded = await GetSeasons();
SetProgressBar(AppResources.SysTrayGettingRecentItems);
bool recentItems = await GetRecentItems().ConfigureAwait(true);
SetProgressBar();
ShowDataLoaded = (seasonsLoaded && recentItems);
}
}
});
SeasonPageLoaded = new RelayCommand(async() =>
{
if (NavigationService.IsNetworkAvailable && !SeasonDataLoaded)
{
if (SelectedSeason != null)
{
SetProgressBar(AppResources.SysTrayGettingEpisodes);
SeasonDataLoaded = await GetEpisodes();
SetProgressBar();
}
}
});
EpisodePageLoaded = new RelayCommand(async() =>
{
});
NextEpisodeCommand = new RelayCommand(() =>
{
if (Episodes.IsNullOrEmpty())
{
return;
}
var episodeIndex = Episodes.IndexOf(SelectedEpisode);
SelectedEpisode = episodeIndex + 1 >= Episodes.Count ? Episodes[0] : Episodes[episodeIndex + 1];
CanResume = SelectedEpisode != null && SelectedEpisode.CanResume;
});
PreviousEpisodeCommand = new RelayCommand(() =>
{
if (Episodes.IsNullOrEmpty())
{
return;
}
var episodeIndex = Episodes.IndexOf(SelectedEpisode);
SelectedEpisode = episodeIndex == 0 ? Episodes[Episodes.Count - 1] : Episodes[episodeIndex - 1];
CanResume = SelectedEpisode != null && SelectedEpisode.CanResume;
});
AddRemoveFavouriteCommand = new RelayCommand <BaseItemDto>(async item =>
{
try
{
SetProgressBar(AppResources.SysTrayAddingToFavourites);
CanUpdateFavourites = false;
item.UserData = await ApiClient.UpdateFavoriteStatusAsync(item.Id, AuthenticationService.Current.LoggedInUserId, !item.UserData.IsFavorite);
}
catch (HttpException ex)
{
if (Utils.HandleHttpException("AddRemoveFavouriteCommand (TV)", ex, NavigationService, Log))
{
SetProgressBar();
return;
}
App.ShowMessage(AppResources.ErrorMakingChanges);
}
SetProgressBar();
CanUpdateFavourites = true;
});
ShowOtherFilmsCommand = new RelayCommand <BaseItemPerson>(person =>
{
App.SelectedItem = person;
NavigationService.NavigateTo(Constants.Pages.ActorView);
});
EpisodeOfflineCommand = new RelayCommand(async() =>
{
await TakeOffline(SelectedEpisode);
});
SeasonOfflineCommand = new RelayCommand(async() =>
{
await TakeOffline(SelectedSeason);
});
ShowOfflineCommand = new RelayCommand(async() =>
{
await TakeOffline(SelectedTvSeries);
}, () => SelectedTvSeries.SupportsSync.HasValue && SelectedTvSeries.SupportsSync.Value);
ItemOfflineCommand = new RelayCommand <BaseItemDto>(async item =>
{
if (!item.CanTakeOffline())
{
return;
}
try
{
var request = SyncRequestHelper.CreateRequest(item.Id, item.GetTvTypeName());
await SyncService.Current.AddJobAsync(request);
}
catch (HttpException ex)
{
Utils.HandleHttpException("ItemOfflineCommand", ex, NavigationService, Log);
}
});
UnsyncItemCommand = new RelayCommand <BaseItemDto>(async item =>
{
try
{
if (item.IsSynced.HasValue && !item.IsSynced.Value)
{
return;
}
await SyncService.Current.UnsyncItem(item.Id);
}
catch (HttpException ex)
{
Utils.HandleHttpException("UnsyncItemCommand", ex, NavigationService, Log);
}
});
NavigateTo = new RelayCommand <BaseItemDto>(NavigationService.NavigateTo);
}
