/// <summary> /// Sets the initial item values. /// </summary> /// <param name="item">The item.</param> /// <param name="parent">The parent.</param> /// <param name="fileSystem">The file system.</param> /// <param name="libraryManager">The library manager.</param> /// <param name="directoryService">The directory service.</param> /// <exception cref="System.ArgumentException">Item must have a path</exception> public static void SetInitialItemValues(BaseItem item, Folder parent, IFileSystem fileSystem, ILibraryManager libraryManager, IDirectoryService directoryService) { // This version of the below method has no ItemResolveArgs, so we have to require the path already being set if (string.IsNullOrWhiteSpace(item.Path)) { throw new ArgumentException("Item must have a Path"); } // If the resolver didn't specify this if (parent != null) { item.Parent = parent; } item.Id = libraryManager.GetNewItemId(item.Path, item.GetType()); item.IsLocked = item.Path.IndexOf("[dontfetchmeta]", StringComparison.OrdinalIgnoreCase) != -1 || item.Parents.Any(i => i.IsLocked); // Make sure DateCreated and DateModified have values var fileInfo = directoryService.GetFile(item.Path); item.DateModified = fileSystem.GetLastWriteTimeUtc(fileInfo); SetDateCreated(item, fileSystem, fileInfo); EnsureName(item, fileInfo); }
public IEnumerable<Audio> GetInstantMixFromFolder(Folder item, User user) { var genres = item .GetRecursiveChildren(user, i => i is Audio) .Cast<Audio>() .SelectMany(i => i.Genres) .Concat(item.Genres) .DistinctNames(); return GetInstantMixFromGenres(genres, user); }
public IEnumerable<Audio> GetInstantMixFromFolder(Folder item, User user) { var genres = item .GetRecursiveChildren(user, new InternalItemsQuery(user) { IncludeItemTypes = new[] {typeof(Audio).Name} }) .Cast<Audio>() .SelectMany(i => i.Genres) .Concat(item.Genres) .DistinctNames(); return GetInstantMixFromGenres(genres, user); }
/// <summary> /// Initializes a new instance of the <see cref="IndexFolder" /> class. /// </summary> /// <param name="parent">The parent.</param> /// <param name="shadow">The shadow.</param> /// <param name="children">The children.</param> /// <param name="indexName">Name of the index.</param> /// <param name="groupContents">if set to <c>true</c> [group contents].</param> public IndexFolder(Folder parent, BaseItem shadow, IEnumerable<BaseItem> children, string indexName, bool groupContents = true) { ChildSource = children; ShadowItem = shadow; GroupContents = groupContents; if (shadow == null) { Name = ForcedSortName = "<Unknown>"; } else { SetShadowValues(); } Id = (parent.Id.ToString() + Name).GetMBId(typeof(IndexFolder)); IndexName = indexName; Parent = parent; }
public static bool IsExcludedFromGrouping(Folder folder) { var standaloneTypes = new List<string> { CollectionType.Books, CollectionType.HomeVideos, CollectionType.Photos }; var collectionFolder = folder as ICollectionFolder; if (collectionFolder == null) { return false; } return standaloneTypes.Contains(collectionFolder.CollectionType ?? string.Empty); }
/// <summary> /// Since it can be slow to make all of these calculations independently, this method will provide a way to do them all at once /// </summary> /// <param name="folder">The folder.</param> /// <param name="user">The user.</param> /// <param name="dto">The dto.</param> /// <param name="userDataRepository">The user data repository.</param> /// <returns>Task.</returns> private static void SetSpecialCounts(Folder folder, User user, BaseItemDto dto, IUserDataRepository userDataRepository) { var rcentlyAddedItemCount = 0; var recursiveItemCount = 0; var unplayed = 0; long runtime = 0; double totalPercentPlayed = 0; // Loop through each recursive child foreach (var child in folder.GetRecursiveChildren(user, true).Where(i => !i.IsFolder).ToList()) { var userdata = userDataRepository.GetUserData(user.Id, child.GetUserDataKey()); recursiveItemCount++; // Check is recently added if (child.IsRecentlyAdded()) { rcentlyAddedItemCount++; } var isUnplayed = true; // Incrememt totalPercentPlayed if (userdata != null) { if (userdata.Played) { totalPercentPlayed += 100; isUnplayed = false; } else if (userdata.PlaybackPositionTicks > 0 && child.RunTimeTicks.HasValue && child.RunTimeTicks.Value > 0) { double itemPercent = userdata.PlaybackPositionTicks; itemPercent /= child.RunTimeTicks.Value; totalPercentPlayed += itemPercent; } } if (isUnplayed) { unplayed++; } runtime += child.RunTimeTicks ?? 0; } dto.RecursiveItemCount = recursiveItemCount; dto.RecentlyAddedItemCount = rcentlyAddedItemCount; dto.RecursiveUnplayedItemCount = unplayed; if (recursiveItemCount > 0) { dto.PlayedPercentage = totalPercentPlayed / recursiveItemCount; } if (runtime > 0) { dto.CumulativeRunTimeTicks = runtime; } }
private int GetChildCount(Folder folder, User user) { return folder.GetChildren(user, true) .Count(); }
private async Task<QueryResult<BaseItem>> GetUserItems(Folder folder, User user, SortCriteria sort, int? startIndex, int? limit) { var sortOrders = new List<string>(); if (!folder.IsPreSorted) { sortOrders.Add(ItemSortBy.SortName); } return await folder.GetUserItems(new UserItemsQuery { Limit = limit, StartIndex = startIndex, SortBy = sortOrders.ToArray(), SortOrder = sort.SortOrder, User = user, Filter = FilterUnsupportedContent }).ConfigureAwait(false); }
private QueryResult <BaseItem> GetMovieCollections(Folder parent, User user, UserItemsQuery query) { return(GetResult(GetRecursiveChildren(parent, user, new[] { CollectionType.Movies, CollectionType.BoxSets, string.Empty }).Where(i => i is BoxSet), query)); }
private void AttachLinkedChildImages(BaseItemDto dto, Folder folder, User user, DtoOptions options) { List<BaseItem> linkedChildren = null; var backdropLimit = options.GetImageLimit(ImageType.Backdrop); if (backdropLimit > 0 && dto.BackdropImageTags.Count == 0) { linkedChildren = user == null ? folder.GetRecursiveChildren().ToList() : folder.GetRecursiveChildren(user).ToList(); var parentWithBackdrop = linkedChildren.FirstOrDefault(i => i.GetImages(ImageType.Backdrop).Any()); if (parentWithBackdrop != null) { dto.ParentBackdropItemId = GetDtoId(parentWithBackdrop); dto.ParentBackdropImageTags = GetBackdropImageTags(parentWithBackdrop, backdropLimit); } } if (!dto.ImageTags.ContainsKey(ImageType.Primary) && options.GetImageLimit(ImageType.Primary) > 0) { if (linkedChildren == null) { linkedChildren = user == null ? folder.GetRecursiveChildren().ToList() : folder.GetRecursiveChildren(user).ToList(); } var parentWithImage = linkedChildren.FirstOrDefault(i => i.GetImages(ImageType.Primary).Any()); if (parentWithImage != null) { dto.ParentPrimaryImageItemId = GetDtoId(parentWithImage); dto.ParentPrimaryImageTag = GetImageCacheTag(parentWithImage, ImageType.Primary); } } }
/// <summary> /// Sets the primary image path. /// </summary> /// <param name="item">The item.</param> /// <param name="parent">The parent.</param> /// <param name="metadataFolder">The metadata folder.</param> /// <param name="episodeFileName">Name of the episode file.</param> private void SetPrimaryImagePath(Episode item, Folder parent, string metadataFolder, string episodeFileName) { // Look for the image file in the metadata folder, and if found, set PrimaryImagePath var imageFiles = new[] { Path.Combine(metadataFolder, Path.ChangeExtension(episodeFileName, ".jpg")), Path.Combine(metadataFolder, Path.ChangeExtension(episodeFileName, ".png")) }; var file = parent.ResolveArgs.GetMetaFileByPath(imageFiles[0]) ?? parent.ResolveArgs.GetMetaFileByPath(imageFiles[1]); if (file != null) { item.PrimaryImagePath = file.FullName; } }
public QueryResult <BaseItem> GetUserItems(Folder queryParent, Folder displayParent, string viewType, InternalItemsQuery query) { var user = query.User; //if (query.IncludeItemTypes != null && // query.IncludeItemTypes.Length == 1 && // string.Equals(query.IncludeItemTypes[0], "Playlist", StringComparison.OrdinalIgnoreCase)) //{ // if (!string.Equals(viewType, CollectionType.Playlists, StringComparison.OrdinalIgnoreCase)) // { // return await FindPlaylists(queryParent, user, query).ConfigureAwait(false); // } //} switch (viewType) { case CollectionType.Folders: return(GetResult(_libraryManager.GetUserRootFolder().GetChildren(user, true), queryParent, query)); case CollectionType.TvShows: return(GetTvView(queryParent, user, query)); case CollectionType.Movies: return(GetMovieFolders(queryParent, user, query)); case SpecialFolder.TvShowSeries: return(GetTvSeries(queryParent, user, query)); case SpecialFolder.TvGenres: return(GetTvGenres(queryParent, user, query)); case SpecialFolder.TvGenre: return(GetTvGenreItems(queryParent, displayParent, user, query)); case SpecialFolder.TvResume: return(GetTvResume(queryParent, user, query)); case SpecialFolder.TvNextUp: return(GetTvNextUp(queryParent, query)); case SpecialFolder.TvLatest: return(GetTvLatest(queryParent, user, query)); case SpecialFolder.MovieFavorites: return(GetFavoriteMovies(queryParent, user, query)); case SpecialFolder.MovieLatest: return(GetMovieLatest(queryParent, user, query)); case SpecialFolder.MovieGenres: return(GetMovieGenres(queryParent, user, query)); case SpecialFolder.MovieGenre: return(GetMovieGenreItems(queryParent, displayParent, user, query)); case SpecialFolder.MovieResume: return(GetMovieResume(queryParent, user, query)); case SpecialFolder.MovieMovies: return(GetMovieMovies(queryParent, user, query)); case SpecialFolder.MovieCollections: return(GetMovieCollections(queryParent, user, query)); case SpecialFolder.TvFavoriteEpisodes: return(GetFavoriteEpisodes(queryParent, user, query)); case SpecialFolder.TvFavoriteSeries: return(GetFavoriteSeries(queryParent, user, query)); default: { if (queryParent is UserView) { return(GetResult(GetMediaFolders(user).OfType <Folder>().SelectMany(i => i.GetChildren(user, true)), queryParent, query)); } return(queryParent.GetItems(query)); } } }
private QueryResult <BaseItem> GetGameSystems(Folder parent, User user, UserItemsQuery query) { return(GetResult(GetRecursiveChildren(parent, user, new[] { CollectionType.Games }).OfType <GameSystem>(), query)); }
private async Task <UserView> GetUserView(string category, string type, User user, string sortName, Folder parent) { var view = await _userViewManager.GetUserView(category, type, user, sortName, CancellationToken.None) .ConfigureAwait(false); if (parent.Id != view.ParentId) { view.ParentId = parent.Id; await view.UpdateToRepository(ItemUpdateType.MetadataImport, CancellationToken.None) .ConfigureAwait(false); } return(view); }
private QueryResult <BaseItem> GetTvSeries(Folder parent, User user, UserItemsQuery query) { return(GetResult(GetRecursiveChildren(parent, user, new[] { CollectionType.TvShows, string.Empty }).OfType <Series>(), query)); }
private QueryResult <BaseItem> GetFavoriteGames(Folder parent, User user, UserItemsQuery query) { query.IsFavorite = true; return(GetResult(GetRecursiveChildren(parent, user, new[] { CollectionType.Games }).OfType <Game>(), query)); }
public async Task <QueryResult <BaseItem> > GetUserItems(Folder parent, string viewType, UserItemsQuery query) { var user = query.User; switch (viewType) { case CollectionType.Channels: { var result = await _channelManager.GetChannelsInternal(new ChannelQuery { UserId = user.Id.ToString("N"), Limit = query.Limit, StartIndex = query.StartIndex }, CancellationToken.None).ConfigureAwait(false); return(GetResult(result)); } case CollectionType.LiveTvChannels: { var result = await _liveTvManager.GetInternalChannels(new LiveTvChannelQuery { UserId = query.User.Id.ToString("N"), Limit = query.Limit, StartIndex = query.StartIndex }, CancellationToken.None).ConfigureAwait(false); return(GetResult(result)); } case CollectionType.LiveTvNowPlaying: { var result = await _liveTvManager.GetRecommendedProgramsInternal(new RecommendedProgramQuery { UserId = query.User.Id.ToString("N"), Limit = query.Limit, IsAiring = true }, CancellationToken.None).ConfigureAwait(false); return(GetResult(result)); } case CollectionType.LiveTvRecordingGroups: { var result = await _liveTvManager.GetInternalRecordings(new RecordingQuery { UserId = query.User.Id.ToString("N"), Status = RecordingStatus.Completed, Limit = query.Limit, StartIndex = query.StartIndex }, CancellationToken.None).ConfigureAwait(false); return(GetResult(result)); } case CollectionType.LiveTv: { var result = await GetLiveTvFolders(user).ConfigureAwait(false); return(GetResult(result, query)); } case CollectionType.Folders: return(GetResult(user.RootFolder.GetChildren(user, true), query)); case CollectionType.Games: return(await GetGameView(user, parent, query).ConfigureAwait(false)); case CollectionType.BoxSets: return(GetResult(GetMediaFolders(user).SelectMany(i => i.GetRecursiveChildren(user)).OfType <BoxSet>(), query)); case CollectionType.TvShows: return(await GetTvView(parent, user, query).ConfigureAwait(false)); case CollectionType.Music: return(await GetMusicFolders(parent, user, query).ConfigureAwait(false)); case CollectionType.Movies: return(await GetMovieFolders(parent, user, query).ConfigureAwait(false)); case CollectionType.GameGenres: return(GetGameGenres(parent, user, query)); case CollectionType.GameSystems: return(GetGameSystems(parent, user, query)); case CollectionType.LatestGames: return(GetLatestGames(parent, user, query)); case CollectionType.RecentlyPlayedGames: return(GetRecentlyPlayedGames(parent, user, query)); case CollectionType.GameFavorites: return(GetFavoriteGames(parent, user, query)); case CollectionType.TvShowSeries: return(GetTvSeries(parent, user, query)); case CollectionType.TvGenres: return(GetTvGenres(parent, user, query)); case CollectionType.TvResume: return(GetTvResume(parent, user, query)); case CollectionType.TvNextUp: return(GetTvNextUp(parent, query)); case CollectionType.TvLatest: return(GetTvLatest(parent, user, query)); case CollectionType.MovieFavorites: return(GetFavoriteMovies(parent, user, query)); case CollectionType.MovieLatest: return(GetMovieLatest(parent, user, query)); case CollectionType.MovieGenres: return(GetMovieGenres(parent, user, query)); case CollectionType.MovieResume: return(GetMovieResume(parent, user, query)); case CollectionType.MovieMovies: return(GetMovieMovies(parent, user, query)); case CollectionType.MovieCollections: return(GetMovieCollections(parent, user, query)); case CollectionType.MusicLatest: return(GetMusicLatest(parent, user, query)); case CollectionType.MusicAlbums: return(GetMusicAlbums(parent, user, query)); case CollectionType.MusicAlbumArtists: return(GetMusicAlbumArtists(parent, user, query)); case CollectionType.MusicArtists: return(GetMusicArtists(parent, user, query)); case CollectionType.MusicSongs: return(GetMusicSongs(parent, user, query)); case CollectionType.TvFavoriteEpisodes: return(GetFavoriteEpisodes(parent, user, query)); case CollectionType.TvFavoriteSeries: return(GetFavoriteSeries(parent, user, query)); default: return(GetResult(GetMediaFolders(user).SelectMany(i => i.GetChildren(user, true)), query)); } }
private QueryResult <BaseItem> GetMusicSongs(Folder parent, User user, UserItemsQuery query) { return(GetResult(GetRecursiveChildren(parent, user, new[] { CollectionType.Music }).Where(i => i is Audio.Audio), query)); }
/// <summary> /// Since it can be slow to make all of these calculations independently, this method will provide a way to do them all at once /// </summary> /// <param name="folder">The folder.</param> /// <param name="user">The user.</param> /// <param name="dto">The dto.</param> /// <param name="fields">The fields.</param> /// <returns>Task.</returns> private void SetSpecialCounts(Folder folder, User user, BaseItemDto dto, List<ItemFields> fields) { var rcentlyAddedItemCount = 0; var recursiveItemCount = 0; var unplayed = 0; long runtime = 0; double totalPercentPlayed = 0; IEnumerable<BaseItem> children; var season = folder as Season; if (season != null) { children = season.GetEpisodes(user).Where(i => i.LocationType != LocationType.Virtual); } else { children = folder.GetRecursiveChildren(user, i => !i.IsFolder && i.LocationType != LocationType.Virtual); } // Loop through each recursive child foreach (var child in children) { var userdata = _userDataRepository.GetUserData(user.Id, child.GetUserDataKey()); recursiveItemCount++; // Check is recently added if (child.IsRecentlyAdded()) { rcentlyAddedItemCount++; } var isUnplayed = true; // Incrememt totalPercentPlayed if (userdata != null) { if (userdata.Played) { totalPercentPlayed += 100; isUnplayed = false; } else if (userdata.PlaybackPositionTicks > 0 && child.RunTimeTicks.HasValue && child.RunTimeTicks.Value > 0) { double itemPercent = userdata.PlaybackPositionTicks; itemPercent /= child.RunTimeTicks.Value; totalPercentPlayed += itemPercent; } } if (isUnplayed) { unplayed++; } runtime += child.RunTimeTicks ?? 0; } dto.RecursiveItemCount = recursiveItemCount; dto.RecentlyAddedItemCount = rcentlyAddedItemCount; dto.RecursiveUnplayedItemCount = unplayed; if (recursiveItemCount > 0) { dto.PlayedPercentage = totalPercentPlayed / recursiveItemCount; } if (runtime > 0 && fields.Contains(ItemFields.CumulativeRunTimeTicks)) { dto.CumulativeRunTimeTicks = runtime; } }
private IEnumerable<BaseItem> GetPlainFolderChildrenSorted(Folder folder, User user, SortCriteria sort) { var items = folder.GetChildren(user, true); items = FilterUnsupportedContent(items); if (folder.IsPreSorted) { return items; } return SortItems(items, user, sort); }
public static bool IsUserSpecific(Folder folder) { var standaloneTypes = new List<string> { CollectionType.Playlists }; var collectionFolder = folder as ICollectionFolder; if (collectionFolder == null) { return false; } var supportsUserSpecific = folder as ISupportsUserSpecificView; if (supportsUserSpecific != null && supportsUserSpecific.EnableUserSpecificView) { return true; } return standaloneTypes.Contains(collectionFolder.CollectionType ?? string.Empty); }
/// <summary> /// Since it can be slow to make all of these calculations independently, this method will provide a way to do them all at once /// </summary> /// <param name="folder">The folder.</param> /// <param name="user">The user.</param> /// <param name="dto">The dto.</param> /// <param name="fields">The fields.</param> /// <param name="syncProgress">The synchronize progress.</param> /// <returns>Task.</returns> private async Task SetSpecialCounts(Folder folder, User user, BaseItemDto dto, List<ItemFields> fields, Dictionary<string, SyncJobItemStatus> syncProgress) { var recursiveItemCount = 0; var unplayed = 0; double totalPercentPlayed = 0; double totalSyncPercent = 0; var children = await folder.GetItems(new InternalItemsQuery { IsFolder = false, Recursive = true, ExcludeLocationTypes = new[] { LocationType.Virtual }, User = user }).ConfigureAwait(false); // Loop through each recursive child foreach (var child in children.Items) { var userdata = _userDataRepository.GetUserData(user, child); recursiveItemCount++; var isUnplayed = true; // Incrememt totalPercentPlayed if (userdata != null) { if (userdata.Played) { totalPercentPlayed += 100; isUnplayed = false; } else if (userdata.PlaybackPositionTicks > 0 && child.RunTimeTicks.HasValue && child.RunTimeTicks.Value > 0) { double itemPercent = userdata.PlaybackPositionTicks; itemPercent /= child.RunTimeTicks.Value; totalPercentPlayed += itemPercent; } } if (isUnplayed) { unplayed++; } double percent = 0; SyncJobItemStatus syncItemProgress; if (syncProgress.TryGetValue(child.Id.ToString("N"), out syncItemProgress)) { switch (syncItemProgress) { case SyncJobItemStatus.Synced: percent = 100; break; case SyncJobItemStatus.Converting: case SyncJobItemStatus.ReadyToTransfer: case SyncJobItemStatus.Transferring: percent = 50; break; } } totalSyncPercent += percent; } dto.RecursiveItemCount = recursiveItemCount; dto.UserData.UnplayedItemCount = unplayed; if (recursiveItemCount > 0) { dto.UserData.PlayedPercentage = totalPercentPlayed / recursiveItemCount; var pct = totalSyncPercent / recursiveItemCount; if (pct > 0) { dto.SyncPercent = pct; } } }
private QueryResult <BaseItem> GetFavoriteEpisodes(Folder parent, User user, UserItemsQuery query) { query.IsFavorite = true; return(GetResult(GetRecursiveChildren(parent, user, new[] { CollectionType.TvShows, string.Empty }).Where(i => i is Episode), query)); }
private int GetChildCount(Folder folder, User user) { // Right now this is too slow to calculate for top level folders on a per-user basis // Just return something so that apps that are expecting a value won't think the folders are empty if (folder is ICollectionFolder || folder is UserView) { return new Random().Next(1, 10); } return folder.GetChildCount(user); }
public static bool IsEligibleForGrouping(Folder folder) { return(folder is ICollectionFolder collectionFolder && IsEligibleForGrouping(collectionFolder.CollectionType)); }
public XmlElement GetFolderElement(XmlDocument doc, Folder folder, int childCount, Filter filter) { var container = doc.CreateElement(string.Empty, "container", NS_DIDL); container.SetAttribute("restricted", "0"); container.SetAttribute("searchable", "1"); container.SetAttribute("childCount", childCount.ToString(_usCulture)); container.SetAttribute("id", folder.Id.ToString("N")); var parent = folder.Parent; if (parent == null) { container.SetAttribute("parentID", "0"); } else { container.SetAttribute("parentID", parent.Id.ToString("N")); } AddCommonFields(folder, container, filter); AddCover(folder, container); return container; }
public static bool IsEligibleForGrouping(Folder folder) { var collectionFolder = folder as ICollectionFolder; return(collectionFolder != null && IsEligibleForGrouping(collectionFolder.CollectionType)); }
public static bool IsEligibleForGrouping(Folder folder) { var collectionFolder = folder as ICollectionFolder; return collectionFolder != null && IsEligibleForGrouping(collectionFolder.CollectionType); }
/// <summary> /// Retrieve all the children of the given folder /// </summary> /// <param name="parent">The parent.</param> /// <returns>IEnumerable{BaseItem}.</returns> /// <exception cref="System.ArgumentNullException"></exception> public IEnumerable<BaseItem> RetrieveChildren(Folder parent) { if (parent == null) { throw new ArgumentNullException(); } using (var cmd = Connection.CreateCommand()) { cmd.CommandText = "select obj_type,data from items where guid in (select child from children where guid = @guid)"; var guidParam = cmd.Parameters.Add("@guid", DbType.Guid); guidParam.Value = parent.Id; using (var reader = cmd.ExecuteReader(CommandBehavior.SequentialAccess | CommandBehavior.SingleResult)) { while (reader.Read()) { var type = reader.GetString(0); using (var stream = GetStream(reader, 1)) { var itemType = _typeMapper.GetType(type); if (itemType == null) { Logger.Error("Cannot find type {0}. Probably belongs to plug-in that is no longer loaded.", type); continue; } var item = _jsonSerializer.DeserializeFromStream(stream, itemType) as BaseItem; if (item != null) { item.Parent = parent; yield return item; } } } } } }
/// <summary> /// Since it can be slow to make all of these calculations independently, this method will provide a way to do them all at once /// </summary> /// <param name="folder">The folder.</param> /// <param name="user">The user.</param> /// <param name="dto">The dto.</param> /// <param name="fields">The fields.</param> /// <param name="syncProgress">The synchronize progress.</param> /// <returns>Task.</returns> private void SetSpecialCounts(Folder folder, User user, BaseItemDto dto, List<ItemFields> fields, Dictionary<string, SyncedItemProgress> syncProgress) { var recursiveItemCount = 0; var unplayed = 0; long runtime = 0; DateTime? dateLastMediaAdded = null; double totalPercentPlayed = 0; double totalSyncPercent = 0; var addSyncInfo = fields.Contains(ItemFields.SyncInfo); var children = folder.GetItems(new InternalItemsQuery { IsFolder = false, Recursive = true, IsVirtualUnaired = false, IsMissing = false, User = user }).Result.Items; // Loop through each recursive child foreach (var child in children) { if (!dateLastMediaAdded.HasValue) { dateLastMediaAdded = child.DateCreated; } else { dateLastMediaAdded = new[] { dateLastMediaAdded.Value, child.DateCreated }.Max(); } var userdata = _userDataRepository.GetUserData(user.Id, child.GetUserDataKey()); recursiveItemCount++; var isUnplayed = true; // Incrememt totalPercentPlayed if (userdata != null) { if (userdata.Played) { totalPercentPlayed += 100; isUnplayed = false; } else if (userdata.PlaybackPositionTicks > 0 && child.RunTimeTicks.HasValue && child.RunTimeTicks.Value > 0) { double itemPercent = userdata.PlaybackPositionTicks; itemPercent /= child.RunTimeTicks.Value; totalPercentPlayed += itemPercent; } } if (isUnplayed) { unplayed++; } runtime += child.RunTimeTicks ?? 0; if (addSyncInfo) { double percent = 0; SyncedItemProgress syncItemProgress; if (syncProgress.TryGetValue(child.Id.ToString("N"), out syncItemProgress)) { switch (syncItemProgress.Status) { case SyncJobItemStatus.Synced: percent = 100; break; case SyncJobItemStatus.Converting: case SyncJobItemStatus.ReadyToTransfer: case SyncJobItemStatus.Transferring: percent = 50; break; } } totalSyncPercent += percent; } } dto.RecursiveItemCount = recursiveItemCount; dto.UserData.UnplayedItemCount = unplayed; if (recursiveItemCount > 0) { dto.UserData.PlayedPercentage = totalPercentPlayed / recursiveItemCount; if (addSyncInfo) { var pct = totalSyncPercent / recursiveItemCount; if (pct > 0) { dto.SyncPercent = pct; } } } if (runtime > 0 && fields.Contains(ItemFields.CumulativeRunTimeTicks)) { dto.CumulativeRunTimeTicks = runtime; } if (fields.Contains(ItemFields.DateLastMediaAdded)) { dto.DateLastMediaAdded = dateLastMediaAdded; } }
private IEnumerable<BaseItem> GetChildrenSorted(Folder folder, User user, SearchCriteria search, SortCriteria sort) { if (search.SearchType == SearchType.Unknown) { return GetChildrenSorted(folder, user, sort); } var items = folder.GetRecursiveChildren(user); items = FilterUnsupportedContent(items); if (search.SearchType == SearchType.Audio) { items = items.OfType<Audio>(); } else if (search.SearchType == SearchType.Video) { items = items.OfType<Video>(); } else if (search.SearchType == SearchType.Image) { items = items.OfType<Photo>(); } else if (search.SearchType == SearchType.Playlist) { } return SortItems(items, user, sort); }
private async Task<QueryResult<BaseItem>> GetChildrenSorted(Folder folder, User user, SearchCriteria search, SortCriteria sort, int? startIndex, int? limit) { var sortOrders = new List<string>(); if (!folder.IsPreSorted) { sortOrders.Add(ItemSortBy.SortName); } var mediaTypes = new List<string>(); bool? isFolder = null; if (search.SearchType == SearchType.Audio) { mediaTypes.Add(MediaType.Audio); isFolder = false; } else if (search.SearchType == SearchType.Video) { mediaTypes.Add(MediaType.Video); isFolder = false; } else if (search.SearchType == SearchType.Image) { mediaTypes.Add(MediaType.Photo); isFolder = false; } else if (search.SearchType == SearchType.Playlist) { //items = items.OfType<Playlist>(); isFolder = true; } else if (search.SearchType == SearchType.MusicAlbum) { //items = items.OfType<MusicAlbum>(); isFolder = true; } return await folder.GetUserItems(new UserItemsQuery { Limit = limit, StartIndex = startIndex, SortBy = sortOrders.ToArray(), SortOrder = sort.SortOrder, User = user, Recursive = true, Filter = FilterUnsupportedContent, IsFolder = isFolder, MediaTypes = mediaTypes.ToArray() }).ConfigureAwait(false); }
private IEnumerable<BaseItem> GetChildrenSorted(Folder folder, User user, SortCriteria sort) { var items = folder.GetChildren(user, true); items = FilterUnsupportedContent(items); if (folder is Series || folder is Season || folder is BoxSet) { return items; } return SortItems(items, user, sort); }
/// <summary> /// Gets indexed folders based on a list of index names and folder id's /// </summary> /// <param name="values">The values.</param> /// <param name="parentFolder">The parent folder.</param> /// <param name="user">The user.</param> /// <returns>BaseItem.</returns> private static BaseItem GetIndexFolder(List<string> values, Folder parentFolder, User user) { // The index name is first var indexBy = values[0]; // The index folder id is next var indexFolderId = new Guid(values[1]); // Remove them from the lst values.RemoveRange(0, 2); // Get the IndexFolder var indexFolder = parentFolder.GetChildren(user, false, indexBy).FirstOrDefault(i => i.Id == indexFolderId) as Folder; // Nested index folder if (values.Count > 0) { return GetIndexFolder(values, indexFolder, user); } return indexFolder; }
private void Browse_AddFolder(XmlDocument result, Folder f, int childCount, Filter filter) { var container = result.CreateElement(string.Empty, "container", NS_DIDL); container.SetAttribute("restricted", "0"); container.SetAttribute("searchable", "1"); container.SetAttribute("childCount", childCount.ToString(_usCulture)); container.SetAttribute("id", f.Id.ToString("N")); var parent = f.Parent; if (parent == null) { container.SetAttribute("parentID", "0"); } else { container.SetAttribute("parentID", parent.Id.ToString("N")); } AddCommonFields(f, container, filter); AddCover(f, container); container.AppendChild(CreateObjectClass(result, f)); result.DocumentElement.AppendChild(container); }
public Task<UserView> GetUserView(Folder parent, string viewType, string sortName, CancellationToken cancellationToken) { return _libraryManager.GetShadowView(parent, viewType, sortName, cancellationToken); }
/// <summary> /// Sets the parents. /// </summary> /// <param name="parent">The parent.</param> /// <param name="kids">The kids.</param> private void SetParents(Folder parent, IEnumerable<IndexFolder> kids) { foreach (var child in kids) { child.ResetParent(parent); child.SetParents(child, child.Children.OfType<IndexFolder>()); } }
public Task<UserView> GetUserView(Folder parent, string viewType, bool enableRichView, string sortName, CancellationToken cancellationToken) { viewType = enableRichView ? viewType : null; return _libraryManager.GetShadowView(parent, viewType, sortName, null, cancellationToken); }
/// <summary> /// Resets the parent. /// </summary> /// <param name="parent">The parent.</param> public void ResetParent(Folder parent) { Parent = parent; Id = (parent.Id.ToString() + Name).GetMBId(typeof(IndexFolder)); }
/// <summary> /// Sets the primary image path. /// </summary> /// <param name="item">The item.</param> /// <param name="parent">The parent.</param> /// <param name="metadataFolder">The metadata folder.</param> /// <param name="episodeFileName">Name of the episode file.</param> private void SetPrimaryImagePath(Episode item, Folder parent, string metadataFolder, string episodeFileName) { foreach (var extension in BaseItem.SupportedImageExtensions) { var path = Path.Combine(metadataFolder, Path.ChangeExtension(episodeFileName, extension)); var file = parent.ResolveArgs.GetMetaFileByPath(path); if (file != null) { item.PrimaryImagePath = file.FullName; return; } } var seasonFolder = Path.GetDirectoryName(item.Path); foreach (var extension in BaseItem.SupportedImageExtensions) { var imageFilename = Path.GetFileNameWithoutExtension(episodeFileName) + "-thumb" + extension; var path = Path.Combine(seasonFolder, imageFilename); var file = parent.ResolveArgs.GetMetaFileByPath(path); if (file != null) { item.PrimaryImagePath = file.FullName; return; } } }
private async Task<QueryResult<BaseItem>> GetChildrenSorted(Folder folder, User user, SortCriteria sort, int? startIndex, int? limit) { if (folder is UserRootFolder) { var result = await _userViewManager.GetUserViews(new UserViewQuery { UserId = user.Id.ToString("N") }, CancellationToken.None).ConfigureAwait(false); return ToResult(result, startIndex, limit); } var view = folder as UserView; if (view != null) { var result = await GetUserViewChildren(view, user, sort).ConfigureAwait(false); return ToResult(result, startIndex, limit); } var channel = folder as Channel; if (channel != null) { try { // Don't blow up here because it could cause parent screens with other content to fail return await _channelManager.GetChannelItemsInternal(new ChannelItemQuery { ChannelId = channel.Id.ToString("N"), Limit = limit, StartIndex = startIndex, UserId = user.Id.ToString("N") }, CancellationToken.None); } catch { // Already logged at lower levels } } var channelFolderItem = folder as ChannelFolderItem; if (channelFolderItem != null) { try { // Don't blow up here because it could cause parent screens with other content to fail return await _channelManager.GetChannelItemsInternal(new ChannelItemQuery { ChannelId = channelFolderItem.ChannelId, FolderId = channelFolderItem.Id.ToString("N"), Limit = limit, StartIndex = startIndex, UserId = user.Id.ToString("N") }, CancellationToken.None); } catch { // Already logged at lower levels } } return ToResult(GetPlainFolderChildrenSorted(folder, user, sort), startIndex, limit); }