private async Task <bool> GetFavouriteItems()
{
try
{
FavouriteItems.Clear();
Log.Info("Getting favourites for user [{0}]", AuthenticationService.Current.LoggedInUser.Name);
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
Filters = new[] { ItemFilter.IsFavorite },
Recursive = true
};
var items = await _apiClient.GetItemsAsync(query);
if (items != null && items.Items != null)
{
foreach (var item in items.Items.Take(6))
{
FavouriteItems.Add(item);
}
}
return(true);
}
catch (HttpException ex)
{
Log.ErrorException("GetFavouriteItems()", ex);
return(false);
}
}
private async Task <bool> GetLatestUnwatched()
{
try
{
SetProgressBar("Getting latest unwatched items...");
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
SortBy = new[] { "DateCreated" },
SortOrder = SortOrder.Descending,
IncludeItemTypes = new[] { "Episode" },
Limit = 8,
Fields = new[] { ItemFields.PrimaryImageAspectRatio, ItemFields.ParentId },
Filters = new[] { ItemFilter.IsUnplayed },
Recursive = true
};
Log.Info("Getting next up items");
var itemResponse = await _apiClient.GetItemsAsync(query);
return(SetLatestUnwatched(itemResponse));
}
catch (HttpException ex)
{
Log.ErrorException("GetLatestUnwatched()", ex);
}
SetProgressBar();
return(false);
}
private async Task GetAlbumTracks()
{
try
{
var query = new ItemQuery
{
ParentId = SelectedAlbum.Id,
IncludeItemTypes = new[] { "Audio" },
UserId = AuthenticationService.Current.LoggedInUserId
};
var tracks = await _apiClient.GetItemsAsync(query);
if (tracks.Items.IsNullOrEmpty())
{
return;
}
AlbumTracks = tracks.Items.OrderBy(x => x.ParentIndexNumber)
.ThenBy(x => x.IndexNumber).ToList();
}
catch (HttpException ex)
{
Log.ErrorException("GetAlbumTracks()", ex);
}
}
private async Task <bool> GetMovies()
{
try
{
SetProgressBar("Getting movies...");
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
SortBy = new[] { "SortName" },
SortOrder = SortOrder.Ascending,
IncludeItemTypes = new[] { "Movie" },
Recursive = true,
Fields = new[] { ItemFields.DateCreated }
};
var moviesResponse = await _apiClient.GetItemsAsync(query);
return(await SetMovies(moviesResponse));
}
catch (HttpException ex)
{
Log.ErrorException("GetMovies()", ex);
}
SetProgressBar();
return(false);
}
private async Task GetAlbumTracks(BaseItemDto item)
{
if (!_navigationService.IsNetworkAvailable)
{
return;
}
SetProgressBar("Getting album tracks...");
try
{
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
Recursive = true,
Fields = new[] { ItemFields.ParentId, },
ParentId = item.Id,
IncludeItemTypes = new[] { "Audio" }
};
Log.Info("Getting tracks for album [{0}] ({1})", item.Name, item.Id);
var itemResponse = await _apiClient.GetItemsAsync(query);
SendItemsToPlaylist(itemResponse);
}
catch (HttpException ex)
{
Log.ErrorException(string.Format("GetAlbumTracks({0})", item.Name), ex);
}
SetProgressBar();
}
private async Task <bool> GetRecentItems()
{
try
{
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
ParentId = SelectedTvSeries.Id,
Filters = new[] { ItemFilter.IsRecentlyAdded },
ExcludeItemTypes = new [] { "Season" },
Fields = new[]
{
ItemFields.ParentId
},
Recursive = true,
IsMissing = App.SpecificSettings.ShowMissingEpisodes,
IsUnaired = App.SpecificSettings.ShowUnairedEpisodes
};
Log.Info("Getting recent items for TV Show [{0}] ({1})", SelectedTvSeries.Name, SelectedTvSeries.Id);
var recent = await _apiClient.GetItemsAsync(query);
if (recent != null && recent.Items != null)
{
RecentItems.Clear();
recent.Items
.OrderByDescending(x => x.DateCreated)
.Take(6)
.ToList()
.ForEach(recentItem => RecentItems.Add(recentItem));
}
return(true);
}
catch (HttpException ex)
{
Log.ErrorException("GetRecentItems()", ex);
App.ShowMessage(AppResources.ErrorRecentItems);
return(false);
}
}
private async Task <bool> GetRecentCollectionItems()
{
var query = new ItemQuery
{
Filters = new[] { ItemFilter.IsRecentlyAdded, ItemFilter.IsNotFolder },
UserId = AuthenticationService.Current.LoggedInUser.Id,
Fields = new[]
{
ItemFields.DateCreated,
ItemFields.ProviderIds,
ItemFields.ParentId,
},
ParentId = SelectedFolder.Id,
Recursive = true
};
try
{
Log.Info("Getting recent items for collection [{0}]", SelectedFolder.Name);
var items = await _apiClient.GetItemsAsync(query);
if (items != null && items.Items != null)
{
var recent = await Utils.SortRecentItems(items.Items, App.SpecificSettings.IncludeTrailersInRecent);
recent.ForEach(item => RecentItems.Add(item));
}
return(true);
}
catch (HttpException ex)
{
Utils.HandleHttpException(ex, "GetRecentCollectionItems()", _navigationService, Log);
return(false);
}
}
private async Task <ItemsResult> GetCollectionItems(int limit)
{
var query = new ItemQuery
{
IncludeItemTypes = new[] { "Season", "Series", "Movie" },
Limit = limit,
SortBy = new[] { ItemSortBy.Random },
UserId = AuthenticationService.Current.LoggedInUser.Id,
ImageTypes = new [] { ImageType.Primary },
Recursive = true
};
if (!string.IsNullOrEmpty(CollectionId))
{
query.ParentId = CollectionId;
}
var itemResponse = await _apiClient.GetItemsAsync(query);
return(itemResponse);
}
private async Task <bool> GetActorInformation()
{
try
{
SetProgressBar("Getting details...");
var actorResponse = await _apiClient.GetPersonAsync(SelectedPerson.Name, AuthenticationService.Current.LoggedInUser.Id);
if (actorResponse == null)
{
return(false);
}
SelectedActor = actorResponse;
var query = new ItemQuery
{
Person = SelectedPerson.Name,
UserId = AuthenticationService.Current.LoggedInUser.Id,
SortBy = new [] { "SortName" },
SortOrder = SortOrder.Ascending,
Fields = new[] { ItemFields.People },
Recursive = true
};
var itemResponse = await _apiClient.GetItemsAsync(query);
return(await SetFilms(itemResponse));
}
catch (HttpException ex)
{
Log.ErrorException("GetActorInformation()", ex);
}
SetProgressBar();
return(false);
}
