protected async Task<IItemDetailSection> GetItemsSection(ItemsResult itemsResult, Func<ItemsResult, bool> listCondition, bool expandSingleItem = true)
{
if (itemsResult.Items.Length == 1 && expandSingleItem && itemsResult.Items[0].IsFolder) {
var query = new ItemQuery { ParentId = itemsResult.Items[0].Id, UserId = _sessionManager.CurrentUser.Id };
return await GetItemsSection(await _apiClient.GetItemsAsync(query), listCondition);
}
if (listCondition(itemsResult)) {
return new ItemsListViewModel(itemsResult, _apiClient, _imageManager, _serverEvents, _navigator, _playbackManager);
}
return new ItemsGridViewModel(itemsResult, _apiClient, _imageManager, _serverEvents, _navigator, _playbackManager);
}
private Task<ItemsResult> GetMovies()
{
var query = new ItemQuery {
UserId = _sessionManager.CurrentUser.Id,
IncludeItemTypes = new[] { "Movie" },
SortBy = new[] { ItemSortBy.SortName },
Fields = QueryFields,
Recursive = true
};
return _apiClient.GetItemsAsync(query);
}
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 Task<ItemsResult> GetAllShows(ItemListViewModel viewModel, DisplayPreferences displayPreferences)
{
var query = new ItemQuery
{
Fields = FolderPage.QueryFields,
UserId = _sessionManager.CurrentUser.Id,
IncludeItemTypes = new[] { "Series" },
SortBy = !String.IsNullOrEmpty(displayPreferences.SortBy)
? new[] { displayPreferences.SortBy }
: new[] { ItemSortBy.SortName },
SortOrder = displayPreferences.SortOrder,
Recursive = true
};
return ApiClient.GetItemsAsync(query, CancellationToken.None);
}
private Task<ItemsResult> GetSoundtracks(ItemListViewModel viewModel)
{
var item = ItemViewModel.Item;
var query = new ItemQuery
{
UserId = _sessionManager.LocalUserId,
Fields = new[]
{
ItemFields.PrimaryImageAspectRatio,
ItemFields.DateCreated
},
Ids = item.SoundtrackIds,
SortBy = new[] { ItemSortBy.SortName }
};
return _apiClient.GetItemsAsync(query, CancellationToken.None);
}
public IEnumerable<BaseItem> RetrieveMusicGenres(ItemQuery query)
{
var dtos = Kernel.ApiClient.GetMusicGenres(query);
return dtos == null ? new BaseItem[] {} : dtos.Items.Select(dto => GetItem(dto, dto.Type)).Where(item => item != null);
}
private async Task<bool> GetAlbums()
{
try
{
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
Artists = new[] {SelectedArtist.Name},
Recursive = true,
Fields = new[] { ItemFields.ParentId,},
IncludeItemTypes = new[] {"MusicAlbum"}
};
Log.Info("Getting albums for artist [{0}] ({1})", SelectedArtist.Name, SelectedArtist.Id);
var items = await _apiClient.GetItemsAsync(query);
if (items != null && items.Items.Any())
{
//// Extract the album items from the results
//var albums = items.Items.Where(x => x.Type == "MusicAlbum").ToList();
//// Extract the track items from the results
//_artistTracks = items.Items.Where(y => y.Type == "Audio").ToList();
//var nameId = (from a in _artistTracks
// select new KeyValuePair<string, string>(a.Album, a.ParentId)).Distinct();
//// This sets the album names correctly based on what's in the track information (rather than folder name)
//foreach (var ni in nameId)
//{
// var item = albums.SingleOrDefault(x => x.Id == ni.Value);
// item.Name = ni.Key;
//}
foreach (var album in items.Items)
{
Albums.Add(album);
}
return true;
}
return false;
}
catch (Exception ex)
{
Log.ErrorException("GetAlbums()", ex);
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<ItemsResult> GetCollectionItems(int limit)
{
var query = new ItemQuery
{
IncludeItemTypes = new[] {"Season", "Series", "Movie"},
Limit = limit,
SortBy = new[] {ItemSortBy.Random},
UserId = AuthenticationService.Current.LoggedInUserId,
ImageTypes = new []{ImageType.Primary},
Recursive = true
};
if (!string.IsNullOrEmpty(CollectionId))
{
query.ParentId = CollectionId;
}
var itemResponse = await _connectionManager.GetApiClient(App.ServerInfo.Id).GetItemsAsync(query);
return itemResponse;
}
private async Task<ItemsResult> GetLatestEpisodes(ItemListViewModel viewModel)
{
var query = new ItemQuery
{
Fields = new[]
{
ItemFields.PrimaryImageAspectRatio,
ItemFields.DateCreated,
ItemFields.DisplayPreferencesId
},
UserId = _sessionManager.CurrentUser.Id,
SortBy = new[] { ItemSortBy.DateCreated },
SortOrder = SortOrder.Descending,
IncludeItemTypes = new[] { "Episode" },
ExcludeLocationTypes = new[] { LocationType.Virtual },
Filters = new[] { ItemFilter.IsUnplayed },
Limit = 9,
Recursive = true
};
var result = await ApiClient.GetItemsAsync(query);
ShowLatestEpisodes = result.TotalRecordCount > 0;
return result;
}
private async Task<ItemsResult> GetRecentlyPlayedAsync(ItemListViewModel viewModel)
{
var query = new ItemQuery
{
Fields = new[]
{
ItemFields.PrimaryImageAspectRatio,
ItemFields.DateCreated,
ItemFields.DisplayPreferencesId
},
UserId = _sessionManager.CurrentUser.Id,
SortBy = new[] { ItemSortBy.DatePlayed },
SortOrder = SortOrder.Descending,
Filters = new[] { ItemFilter.IsPlayed },
IncludeItemTypes = new[] { "Game" },
Recursive = true,
Limit = 6
};
var result = await ApiClient.GetItemsAsync(query);
ShowRecentlyPlayed = result.Items.Length > 0;
return result;
}
private Task<ItemsResult> GetGameSystems(ItemListViewModel viewModel)
{
var query = new ItemQuery
{
Fields = new[]
{
ItemFields.PrimaryImageAspectRatio,
ItemFields.DateCreated,
ItemFields.DisplayPreferencesId
},
UserId = _sessionManager.CurrentUser.Id,
SortBy = new[] { ItemSortBy.SortName },
IncludeItemTypes = new[] { "GameSystem" },
Recursive = true
};
return ApiClient.GetItemsAsync(query);
}
private async Task<bool> GetLatestUnwatched()
{
try
{
SetProgressBar(AppResources.SysTrayGettingUnwatchedItems);
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUserId,
SortBy = new[] {"DateCreated"},
SortOrder = SortOrder.Descending,
IncludeItemTypes = new[] {"Movie"},
Limit = 9,
Fields = new[] {ItemFields.PrimaryImageAspectRatio},
Filters = new[] {ItemFilter.IsUnplayed},
Recursive = true,
ImageTypeLimit = 1,
EnableImageTypes = new[] { ImageType.Backdrop, ImageType.Primary, }
};
Log.Info("Getting next up items");
var itemResponse = await ApiClient.GetItemsAsync(query);
return SetLatestUnwatched(itemResponse);
}
catch (HttpException ex)
{
Utils.HandleHttpException("GetLatestUnwatched()", ex, NavigationService, Log);
}
SetProgressBar();
return false;
}
private async Task<bool> GetBoxsets()
{
try
{
SetProgressBar(AppResources.SysTrayGettingBoxsets);
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUserId,
SortBy = new[] {"SortName"},
SortOrder = SortOrder.Ascending,
IncludeItemTypes = new[] {"BoxSet"},
Recursive = true,
ImageTypeLimit = 1,
EnableImageTypes = new[] { ImageType.Backdrop, ImageType.Primary, }
};
var itemResponse = await ApiClient.GetItemsAsync(query);
return await SetBoxsets(itemResponse);
}
catch (HttpException ex)
{
Utils.HandleHttpException("GetBoxsets()", ex, NavigationService, Log);
}
SetProgressBar();
return false;
}
private async Task<bool> GetItems()
{
try
{
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUserId,
SortBy = new[] {ItemSortBy.SortName},
SortOrder = SortOrder.Ascending,
Fields = new[]
{
ItemFields.SortName,
ItemFields.Genres,
ItemFields.ProviderIds,
ItemFields.ParentId,
ItemFields.CumulativeRunTimeTicks
},
ExcludeItemTypes = SelectedFolder != null && SelectedFolder.Name.ToLower().Contains("recent") ? new[] {"Season", "Series"} : null,
ImageTypeLimit = 1,
EnableImageTypes = new[] { ImageType.Backdrop, ImageType.Primary, }
};
var isRecent = false;
if (SelectedPerson != null)
{
Log.Info("Getting items for {0}", SelectedPerson.Name);
PageTitle = SelectedPerson.Name.ToLower();
query.Person = SelectedPerson.Name;
query.PersonTypes = new[] {SelectedPerson.Type};
query.Recursive = true;
}
else
{
if (SelectedFolder.Name.Contains(AppResources.LabelRecent.ToLower()))
{
Log.Info("Getting recent items");
PageTitle = AppResources.LabelRecent.ToLower();
query = Utils.GetRecentItemsQuery(excludedItemTypes: new[] {"Photo", "Season", "Series"});
isRecent = true;
}
else if (SelectedFolder.Name.Equals(AppResources.Favourites.ToLower()))
{
Log.Info("Getting favourite items");
PageTitle = AppResources.Favourites.ToLower();
query.Filters = new[] {ItemFilter.IsFavorite};
query.Recursive = true;
}
else if (SelectedFolder.Type.StartsWith(AppResources.Genre))
{
Log.Info("Getting items for genre [{0}]", SelectedFolder.Name);
PageTitle = SelectedFolder.Name.ToLower();
query.Genres = new[] {SelectedFolder.Name};
query.Recursive = true;
if (SelectedFolder.Type.Contains(" - " + AppResources.LabelTv.ToUpper()))
{
query.IncludeItemTypes = new[] {"Series"};
}
else if (SelectedFolder.Type.Contains(" - " + AppResources.LabelMovies.ToUpper()))
{
query.ExcludeItemTypes = new[] { "Series" };
query.IncludeItemTypes = new[] {"Movie", "Trailer"};
}
}
else
{
Log.Info("Getting items for folder [{0}]", SelectedFolder.Name);
PageTitle = SelectedFolder.Name.ToLower();
query.ParentId = SelectedFolder.Id;
}
}
var items = await ApiClient.GetItemsAsync(query);
CurrentItems = isRecent ? await Utils.SortRecentItems(items.Items, App.SpecificSettings.IncludeTrailersInRecent) : items.Items.ToList();
return true;
}
catch (HttpException ex)
{
Utils.HandleHttpException("GetItems()", ex, NavigationService, Log);
App.ShowMessage(AppResources.ErrorGettingData);
return false;
}
}
private Task<ItemsResult> GetComedyMovies(ItemListViewModel viewModel, DisplayPreferences displayPreferences)
{
var query = new ItemQuery
{
Fields = FolderPage.QueryFields,
UserId = _sessionManager.CurrentUser.Id,
IncludeItemTypes = new[] { "Movie" },
Genres = new[] { ApiClientExtensions.ComedyGenre },
SortBy = !String.IsNullOrEmpty(displayPreferences.SortBy)
? new[] { displayPreferences.SortBy }
: new[] { ItemSortBy.SortName },
SortOrder = displayPreferences.SortOrder,
Recursive = true
};
return ApiClient.GetItemsAsync(query);
}
private async Task<Boolean> GeSearchPeopleAsync()
{
SearchHintResult searchHintResult = await _apiClient.GetSearchHintsAsync(new SearchQuery { UserId = _apiClient.CurrentUserId, SearchTerm = CurrentSearch, IncludePeople = true, IncludeArtists = false, IncludeGenres = false, IncludeMedia = false, IncludeStudios = false, Limit = 9 });
var ids = (searchHintResult.TotalRecordCount > 0) ? searchHintResult.SearchHints.Select(s => s.ItemId).ToArray() : null;
if (ids != null && ids.Length > 0)
{
var query = new ItemQuery
{
Ids = ids,
UserId = _apiClient.CurrentUserId,
Fields = FolderPage.QueryFields
};
_searchedPeopleItemsResult = await _apiClient.GetItemsAsync(query);
}
else
{
_searchedPeopleItemsResult = _emptyItemsResult;
}
return true;
}
void NavigateToPerson(string name, string[] personTypes)
{
Async.Queue(Async.ThreadPoolName.PersonNavigation, () =>
{
ProgressBox(string.Format("Finding items with {0} in them...", name));
var person = Kernel.Instance.MB3ApiRepository.RetrievePerson(name) ?? new Person();
var query = new ItemQuery
{
UserId = Kernel.CurrentUser.Id.ToString(),
Fields = MB3ApiRepository.StandardFields,
PersonIds = new [] {person.ApiId},
PersonTypes = personTypes,
Recursive = true
};
var index = new SearchResultFolder(Kernel.Instance.MB3ApiRepository.RetrieveItems(query).ToList()) {Name = name, Overview = person.Overview};
ShowMessage = false;
Application.UIDeferredInvokeIfRequired(() => Navigate(ItemFactory.Instance.Create(index)));
});
}
private async Task<bool> GetArtistTracks()
{
try
{
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
Artists = new[] {SelectedArtist.Name},
Recursive = true,
Fields = new[] { ItemFields.ParentId,},
IncludeItemTypes = new[] {"Audio"}
};
Log.Info("Getting tracks for artist [{0}] ({1})", SelectedArtist.Name, SelectedArtist.Id);
var items = await _apiClient.GetItemsAsync(query);
if (items != null && items.Items.Any())
{
_artistTracks = items.Items.ToList();
}
return true;
}
catch (HttpException ex)
{
Log.ErrorException("GetArtistTracks()", ex);
return false;
}
}
public void NavigateToGenre(string genre, Item currentMovie, string itemType)
{
switch (currentMovie.BaseItem.GetType().Name)
{
case "Series":
case "Season":
case "Episode":
itemType = "Series";
break;
case "MusicAlbum":
case "MusicArtist":
case "MusicGenre":
case "Song":
itemType = "MusicAlbum";
break;
case "Game":
itemType = "Game";
break;
}
Async.Queue(Async.ThreadPoolName.GenreNavigation, () =>
{
ProgressBox(string.Format("Finding items in the {0} genre...", genre));
var searchStart = GetStartingFolder(currentMovie.BaseItem.Parent);
var query = new ItemQuery
{
UserId = Kernel.CurrentUser.Id.ToString(),
Fields = MB3ApiRepository.StandardFields,
ParentId = searchStart.ApiId,
Genres = new[] {genre},
IncludeItemTypes = new [] {itemType},
Recursive = true
};
var index = new SearchResultFolder(Kernel.Instance.MB3ApiRepository.RetrieveItems(query).ToList()) {Name = genre};
ShowMessage = false;
Navigate(ItemFactory.Instance.Create(index));
});
}
private ListPageConfig GetListPageConfig(BaseItemDto item, ViewType context)
{
var apiClient = _connectionManager.GetApiClient(item);
var config = new ListPageConfig();
if (item.IsType("playlist"))
{
config.DefaultViewType = ListViewTypes.List;
}
if (context == ViewType.Tv || item.IsType("season"))
{
TvViewModel.SetDefaults(config);
if (item.IsType("season"))
{
config.DefaultViewType = ListViewTypes.List;
config.PosterImageWidth = 480;
config.PosterStripImageWidth = 592;
config.ThumbImageWidth = 592;
}
}
else if (context == ViewType.Movies)
{
MoviesViewModel.SetDefaults(config);
}
else if (context == ViewType.Games)
{
GamesViewModel.SetDefaults(config, item.GameSystem);
}
if (item.IsFolder)
{
config.CustomItemQuery = (vm, displayPreferences) =>
{
if (item.IsType("series"))
{
return apiClient.GetSeasonsAsync(new SeasonQuery
{
UserId = _sessionManager.LocalUserId,
SeriesId = item.Id,
Fields = FolderPage.QueryFields
}, CancellationToken.None);
}
if (item.IsType("season"))
{
return apiClient.GetEpisodesAsync(new EpisodeQuery
{
UserId = _sessionManager.LocalUserId,
SeriesId = item.SeriesId,
SeasonId = item.Id,
Fields = FolderPage.QueryFields
}, CancellationToken.None);
}
var query = new ItemQuery
{
UserId = _sessionManager.LocalUserId,
ParentId = item.Id,
Fields = FolderPage.QueryFields
};
// Server will sort boxset titles based on server settings
if (!item.IsType("boxset"))
{
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = displayPreferences.SortOrder;
}
return apiClient.GetItemsAsync(query, CancellationToken.None);
};
if (item.IsType("season") && item.IndexNumber.HasValue && item.IndexNumber.Value > 0)
{
config.DisplayNameGenerator = FolderPage.GetDisplayNameWithAiredSpecial;
}
}
return config;
}
private Task<ItemsResult> GetChildren(ItemListViewModel viewModel)
{
var item = ItemViewModel.Item;
var query = new ItemQuery
{
UserId = _sessionManager.CurrentUser.Id,
Fields = new[]
{
ItemFields.PrimaryImageAspectRatio,
ItemFields.DateCreated,
ItemFields.Overview
},
ParentId = item.Id,
SortBy = new[] { ItemSortBy.SortName }
};
return _apiClient.GetItemsAsync(query, CancellationToken.None);
}
private Task<ItemsResult> GetItemByNameItemsAsync(string type)
{
var item = ItemViewModel.Item;
var query = new ItemQuery
{
UserId = _sessionManager.LocalUserId,
Fields = new[]
{
ItemFields.PrimaryImageAspectRatio,
ItemFields.DateCreated
},
SortBy = new[] { ItemSortBy.SortName },
IncludeItemTypes = new[] { type },
Recursive = true
};
if (item.IsPerson)
{
query.PersonIds = new[] { item.Id };
}
else if (item.IsStudio)
{
query.StudioIds = new[] { item.Id };
}
else if (item.IsGenre || item.IsMusicGenre || item.IsGameGenre)
{
query.Genres = new[] { item.Name };
}
else if (item.IsArtist)
{
query.ArtistIds = new[] { item.Id };
}
return _apiClient.GetItemsAsync(query, CancellationToken.None);
}
private async Task<ItemsResult> GetCollectionItems(int limit, ImageType imageType = ImageType.Primary)
{
var query = new ItemQuery
{
IncludeItemTypes = new[] { "Season", "Series", "Movie", "Album" },
Limit = limit,
SortBy = new[] { ItemSortBy.Random },
UserId = AuthenticationService.Current.LoggedInUserId,
ImageTypes = new[] { imageType },
Recursive = true
};
try
{
var itemResponse = await _connectionManager.GetApiClient(App.ServerInfo.Id).GetItemsAsync(query);
return itemResponse;
}
catch (HttpException ex)
{
_logger.ErrorException("GetCollectionItems(" + imageType + ")", ex);
}
return null;
}
private Task<ItemsResult> GetAlbumSongs(ItemListViewModel viewModel)
{
var item = ItemViewModel.Item;
var query = new ItemQuery
{
UserId = _sessionManager.LocalUserId,
Fields = new[]
{
ItemFields.PrimaryImageAspectRatio,
ItemFields.DateCreated,
ItemFields.Overview
},
ParentId = item.Id,
SortBy = new[] { ItemSortBy.SortName },
Recursive = true,
IncludeItemTypes = new[] { "Audio" }
};
return _apiClient.GetItemsAsync(query, CancellationToken.None);
}
private Task<ItemsResult> GetMovies(ItemListViewModel viewModel, DisplayPreferences displayPreferences)
{
var query = new ItemQuery
{
Fields = FolderPage.QueryFields,
UserId = _sessionManager.CurrentUser.Id,
IncludeItemTypes = new[] { "Movie" },
SortBy = !String.IsNullOrEmpty(displayPreferences.SortBy)
? new[] { displayPreferences.SortBy }
: new[] { ItemSortBy.SortName },
SortOrder = displayPreferences.SortOrder,
Recursive = true
};
var indexOption = viewModel.CurrentIndexOption == null ? string.Empty : viewModel.CurrentIndexOption.Name;
if (string.Equals(indexOption, "TopRated"))
{
query.MinCommunityRating = ApiClientExtensions.TopMovieCommunityRating;
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (string.Equals(indexOption, "Unwatched"))
{
query.Filters = new[] { ItemFilter.IsUnplayed };
}
else if (string.Equals(indexOption, "NewReleases"))
{
query.SortBy = new[] { ItemSortBy.ProductionYear, ItemSortBy.PremiereDate };
query.SortOrder = SortOrder.Descending;
query.Limit = 100;
}
else if (string.Equals(indexOption, "HDMovies"))
{
query.IsHD = true;
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (string.Equals(indexOption, "3DMovies"))
{
query.Is3D = true;
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (string.Equals(indexOption, "Trailers"))
{
query.IncludeItemTypes = new[] { "Trailer" };
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (string.Equals(indexOption, "BoxSets"))
{
query.IncludeItemTypes = new[] { "BoxSet" };
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (string.Equals(indexOption, "FavoriteMovies"))
{
query.Filters = new[] { ItemFilter.IsFavorite };
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (string.Equals(indexOption, "TopCriticRated"))
{
query.MinCriticRating = 95;
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (string.Equals(indexOption, "Family"))
{
query.Genres = new[] { "Family" };
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (indexOption.StartsWith("Genre:"))
{
query.Genres = new[] { indexOption.Split(':').Last() };
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
else if (indexOption.StartsWith("Studio:"))
{
query.Studios = new[] { indexOption.Split(':').Last() };
query.SortBy = new[] { ItemSortBy.SortName };
query.SortOrder = SortOrder.Ascending;
}
return ApiClient.GetItemsAsync(query);
}
private Task<ItemsResult> GetSeriesByGenre(ItemListViewModel viewModel, DisplayPreferences displayPreferences)
{
var query = new ItemQuery
{
Fields = FolderPage.QueryFields,
UserId = _sessionManager.LocalUserId,
IncludeItemTypes = new[] { "Series" },
SortBy = !String.IsNullOrEmpty(displayPreferences.SortBy)
? new[] { displayPreferences.SortBy }
: new[] { ItemSortBy.SortName },
SortOrder = displayPreferences.SortOrder,
Recursive = true,
ParentId = ParentId
};
var indexOption = viewModel.CurrentIndexOption;
if (indexOption != null)
{
query.Genres = new[] { indexOption.Name };
}
return ApiClient.GetItemsAsync(query, CancellationToken.None);
}
private Task<ItemsResult> GetMoviesByYear(ItemListViewModel viewModel, DisplayPreferences displayPreferences)
{
var query = new ItemQuery
{
Fields = FolderPage.QueryFields,
UserId = _sessionManager.CurrentUser.Id,
IncludeItemTypes = new[] { "Movie" },
SortBy = !String.IsNullOrEmpty(displayPreferences.SortBy)
? new[] { displayPreferences.SortBy }
: new[] { ItemSortBy.SortName },
SortOrder = displayPreferences.SortOrder,
Recursive = true
};
var indexOption = viewModel.CurrentIndexOption;
if (indexOption != null)
{
query.Years = new[] { int.Parse(indexOption.Name) };
}
return ApiClient.GetItemsAsync(query);
}
private async Task<bool> GetShows()
{
try
{
SetProgressBar("Getting TV shows...");
var query = new ItemQuery
{
UserId = AuthenticationService.Current.LoggedInUser.Id,
SortBy = new[] { "SortName" },
SortOrder = SortOrder.Ascending,
IncludeItemTypes = new[] { "Series" },
Fields = new[] { ItemFields.DateCreated },
Recursive = true
};
Log.Info("Getting TV shows");
var itemResponse = await _apiClient.GetItemsAsync(query);
return await SetShows(itemResponse);
}
catch (HttpException ex)
{
Log.ErrorException("GetShows()", ex);
}
SetProgressBar();
return false;
}
private Task<ItemsResult> GetLatestMoviesAsync(ItemListViewModel viewModel)
{
var query = new ItemQuery
{
Fields = new[]
{
ItemFields.PrimaryImageAspectRatio,
ItemFields.DateCreated,
ItemFields.DisplayPreferencesId
},
UserId = _sessionManager.CurrentUser.Id,
SortBy = new[] { ItemSortBy.DateCreated },
SortOrder = SortOrder.Descending,
IncludeItemTypes = new[] { "Movie" },
Filters = new[] { ItemFilter.IsUnplayed },
Limit = 8,
Recursive = true
};
return ApiClient.GetItemsAsync(query);
}
