Ejemplo n.º 1
0
        protected ItemsResult GetResultSlim(GetItemsByName request)
        {
            var dtoOptions = GetDtoOptions(request);

            User     user = null;
            BaseItem parentItem;

            if (!string.IsNullOrWhiteSpace(request.UserId))
            {
                user       = UserManager.GetUserById(request.UserId);
                parentItem = string.IsNullOrEmpty(request.ParentId) ? user.RootFolder : LibraryManager.GetItemById(request.ParentId);
            }
            else
            {
                parentItem = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.RootFolder : LibraryManager.GetItemById(request.ParentId);
            }

            var excludeItemTypes = request.GetExcludeItemTypes();
            var includeItemTypes = request.GetIncludeItemTypes();
            var mediaTypes       = request.GetMediaTypes();

            var query = new InternalItemsQuery(user)
            {
                ExcludeItemTypes               = excludeItemTypes,
                IncludeItemTypes               = includeItemTypes,
                MediaTypes                     = mediaTypes,
                StartIndex                     = request.StartIndex,
                Limit                          = request.Limit,
                IsFavorite                     = request.IsFavorite,
                NameLessThan                   = request.NameLessThan,
                NameStartsWith                 = request.NameStartsWith,
                NameStartsWithOrGreater        = request.NameStartsWithOrGreater,
                AlbumArtistStartsWithOrGreater = request.AlbumArtistStartsWithOrGreater,
                Tags               = request.GetTags(),
                OfficialRatings    = request.GetOfficialRatings(),
                Genres             = request.GetGenres(),
                GenreIds           = request.GetGenreIds(),
                Studios            = request.GetStudios(),
                StudioIds          = request.GetStudioIds(),
                Person             = request.Person,
                PersonIds          = request.GetPersonIds(),
                PersonTypes        = request.GetPersonTypes(),
                Years              = request.GetYears(),
                MinCommunityRating = request.MinCommunityRating
            };

            if (!string.IsNullOrWhiteSpace(request.ParentId))
            {
                if (parentItem is Folder)
                {
                    query.AncestorIds = new[] { request.ParentId };
                }
                else
                {
                    query.ItemIds = new[] { request.ParentId };
                }
            }

            foreach (var filter in request.GetFilters())
            {
                switch (filter)
                {
                case ItemFilter.Dislikes:
                    query.IsLiked = false;
                    break;

                case ItemFilter.IsFavorite:
                    query.IsFavorite = true;
                    break;

                case ItemFilter.IsFavoriteOrLikes:
                    query.IsFavoriteOrLiked = true;
                    break;

                case ItemFilter.IsFolder:
                    query.IsFolder = true;
                    break;

                case ItemFilter.IsNotFolder:
                    query.IsFolder = false;
                    break;

                case ItemFilter.IsPlayed:
                    query.IsPlayed = true;
                    break;

                case ItemFilter.IsRecentlyAdded:
                    break;

                case ItemFilter.IsResumable:
                    query.IsResumable = true;
                    break;

                case ItemFilter.IsUnplayed:
                    query.IsPlayed = false;
                    break;

                case ItemFilter.Likes:
                    query.IsLiked = true;
                    break;
                }
            }

            var result = GetItems(request, query);

            var syncProgess = DtoService.GetSyncedItemProgress(dtoOptions);
            var dtos        = result.Items.Select(i =>
            {
                var dto = DtoService.GetItemByNameDto(i.Item1, dtoOptions, null, syncProgess, user);

                if (!string.IsNullOrWhiteSpace(request.IncludeItemTypes))
                {
                    SetItemCounts(dto, i.Item2);
                }
                return(dto);
            });

            return(new ItemsResult
            {
                Items = dtos.ToArray(),
                TotalRecordCount = result.TotalRecordCount
            });
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Gets the specified request.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>Task{ItemsResult}.</returns>
        protected ItemsResult GetResult(GetItemsByName request)
        {
            var dtoOptions = GetDtoOptions(request);

            User            user = null;
            BaseItem        parentItem;
            List <BaseItem> libraryItems = null;

            if (!string.IsNullOrWhiteSpace(request.UserId))
            {
                user       = UserManager.GetUserById(request.UserId);
                parentItem = string.IsNullOrEmpty(request.ParentId) ? user.RootFolder : LibraryManager.GetItemById(request.ParentId);

                if (RequiresLibraryItems(request, dtoOptions))
                {
                    libraryItems = user.RootFolder.GetRecursiveChildren(user).ToList();
                }
            }
            else
            {
                parentItem = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.RootFolder : LibraryManager.GetItemById(request.ParentId);
                if (RequiresLibraryItems(request, dtoOptions))
                {
                    libraryItems = LibraryManager.RootFolder.GetRecursiveChildren().ToList();
                }
            }

            IEnumerable <BaseItem> items;

            var excludeItemTypes = request.GetExcludeItemTypes();
            var includeItemTypes = request.GetIncludeItemTypes();
            var mediaTypes       = request.GetMediaTypes();

            var query = new InternalItemsQuery(user)
            {
                ExcludeItemTypes = excludeItemTypes,
                IncludeItemTypes = includeItemTypes,
                MediaTypes       = mediaTypes
            };

            Func <BaseItem, bool> filter = i => FilterItem(request, i, excludeItemTypes, includeItemTypes, mediaTypes);

            if (parentItem.IsFolder)
            {
                var folder = (Folder)parentItem;

                if (!string.IsNullOrWhiteSpace(request.UserId))
                {
                    items = request.Recursive ?
                            folder.GetRecursiveChildren(user, query) :
                            folder.GetChildren(user, true).Where(filter);
                }
                else
                {
                    items = request.Recursive ?
                            folder.GetRecursiveChildren(filter) :
                            folder.Children.Where(filter);
                }
            }
            else
            {
                items = new[] { parentItem }.Where(filter);
            }

            var extractedItems = GetAllItems(request, items);

            var filteredItems = FilterItems(request, extractedItems, user);

            filteredItems = FilterByLibraryItems(request, filteredItems.Cast <IItemByName>(), user, libraryItems).Cast <BaseItem>();

            filteredItems = LibraryManager.Sort(filteredItems, user, request.GetOrderBy(), request.SortOrder ?? SortOrder.Ascending);

            var ibnItemsArray = filteredItems.ToList();

            IEnumerable <BaseItem> ibnItems = ibnItemsArray;

            var result = new ItemsResult
            {
                TotalRecordCount = ibnItemsArray.Count
            };

            if (request.StartIndex.HasValue || request.Limit.HasValue)
            {
                if (request.StartIndex.HasValue)
                {
                    ibnItems = ibnItems.Skip(request.StartIndex.Value);
                }

                if (request.Limit.HasValue)
                {
                    ibnItems = ibnItems.Take(request.Limit.Value);
                }
            }

            IEnumerable <Tuple <BaseItem, List <BaseItem> > > tuples;

            if (dtoOptions.Fields.Contains(ItemFields.ItemCounts))
            {
                tuples = ibnItems.Select(i => new Tuple <BaseItem, List <BaseItem> >(i, ((IItemByName)i).GetTaggedItems(libraryItems).ToList()));
            }
            else
            {
                tuples = ibnItems.Select(i => new Tuple <BaseItem, List <BaseItem> >(i, new List <BaseItem>()));
            }

            var syncProgess = DtoService.GetSyncedItemProgress(dtoOptions);
            var dtos        = tuples.Select(i => DtoService.GetItemByNameDto(i.Item1, dtoOptions, i.Item2, syncProgess, user));

            result.Items = dtos.Where(i => i != null).ToArray();

            return(result);
        }
Ejemplo n.º 3
0
        protected QueryResult <BaseItemDto> GetResultSlim(GetItemsByName request)
        {
            var dtoOptions = GetDtoOptions(AuthorizationContext, request);

            User     user = null;
            BaseItem parentItem;

            if (!request.UserId.Equals(Guid.Empty))
            {
                user       = UserManager.GetUserById(request.UserId);
                parentItem = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.GetUserRootFolder() : LibraryManager.GetItemById(request.ParentId);
            }
            else
            {
                parentItem = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.RootFolder : LibraryManager.GetItemById(request.ParentId);
            }

            var excludeItemTypes = request.GetExcludeItemTypes();
            var includeItemTypes = request.GetIncludeItemTypes();
            var mediaTypes       = request.GetMediaTypes();

            var query = new InternalItemsQuery(user)
            {
                ExcludeItemTypes        = excludeItemTypes,
                IncludeItemTypes        = includeItemTypes,
                MediaTypes              = mediaTypes,
                StartIndex              = request.StartIndex,
                Limit                   = request.Limit,
                IsFavorite              = request.IsFavorite,
                NameLessThan            = request.NameLessThan,
                NameStartsWith          = request.NameStartsWith,
                NameStartsWithOrGreater = request.NameStartsWithOrGreater,
                Tags                   = request.GetTags(),
                OfficialRatings        = request.GetOfficialRatings(),
                Genres                 = request.GetGenres(),
                GenreIds               = GetGuids(request.GenreIds),
                StudioIds              = GetGuids(request.StudioIds),
                Person                 = request.Person,
                PersonIds              = GetGuids(request.PersonIds),
                PersonTypes            = request.GetPersonTypes(),
                Years                  = request.GetYears(),
                MinCommunityRating     = request.MinCommunityRating,
                DtoOptions             = dtoOptions,
                SearchTerm             = request.SearchTerm,
                EnableTotalRecordCount = request.EnableTotalRecordCount
            };

            if (!string.IsNullOrWhiteSpace(request.ParentId))
            {
                if (parentItem is Folder)
                {
                    query.AncestorIds = new[] { new Guid(request.ParentId) };
                }
                else
                {
                    query.ItemIds = new[] { new Guid(request.ParentId) };
                }
            }

            // Studios
            if (!string.IsNullOrEmpty(request.Studios))
            {
                query.StudioIds = request.Studios.Split('|').Select(i =>
                {
                    try
                    {
                        return(LibraryManager.GetStudio(i));
                    }
                    catch
                    {
                        return(null);
                    }
                }).Where(i => i != null).Select(i => i.Id).ToArray();
            }

            foreach (var filter in request.GetFilters())
            {
                switch (filter)
                {
                case ItemFilter.Dislikes:
                    query.IsLiked = false;
                    break;

                case ItemFilter.IsFavorite:
                    query.IsFavorite = true;
                    break;

                case ItemFilter.IsFavoriteOrLikes:
                    query.IsFavoriteOrLiked = true;
                    break;

                case ItemFilter.IsFolder:
                    query.IsFolder = true;
                    break;

                case ItemFilter.IsNotFolder:
                    query.IsFolder = false;
                    break;

                case ItemFilter.IsPlayed:
                    query.IsPlayed = true;
                    break;

                case ItemFilter.IsResumable:
                    query.IsResumable = true;
                    break;

                case ItemFilter.IsUnplayed:
                    query.IsPlayed = false;
                    break;

                case ItemFilter.Likes:
                    query.IsLiked = true;
                    break;
                }
            }

            var result = GetItems(request, query);

            var dtos = result.Items.Select(i =>
            {
                var dto = DtoService.GetItemByNameDto(i.Item1, dtoOptions, null, user);

                if (!string.IsNullOrWhiteSpace(request.IncludeItemTypes))
                {
                    SetItemCounts(dto, i.Item2);
                }
                return(dto);
            });

            return(new QueryResult <BaseItemDto>
            {
                Items = dtos.ToArray(),
                TotalRecordCount = result.TotalRecordCount
            });
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Gets the specified request.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>Task{ItemsResult}.</returns>
        protected QueryResult <BaseItemDto> GetResult(GetItemsByName request)
        {
            var dtoOptions = GetDtoOptions(AuthorizationContext, request);

            User     user = null;
            BaseItem parentItem;

            if (!request.UserId.Equals(Guid.Empty))
            {
                user       = UserManager.GetUserById(request.UserId);
                parentItem = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.GetUserRootFolder() : LibraryManager.GetItemById(request.ParentId);
            }
            else
            {
                parentItem = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.RootFolder : LibraryManager.GetItemById(request.ParentId);
            }

            IList <BaseItem> items;

            var excludeItemTypes = request.GetExcludeItemTypes();
            var includeItemTypes = request.GetIncludeItemTypes();
            var mediaTypes       = request.GetMediaTypes();

            var query = new InternalItemsQuery(user)
            {
                ExcludeItemTypes = excludeItemTypes,
                IncludeItemTypes = includeItemTypes,
                MediaTypes       = mediaTypes,
                DtoOptions       = dtoOptions
            };

            bool Filter(BaseItem i) => FilterItem(request, i, excludeItemTypes, includeItemTypes, mediaTypes);

            if (parentItem.IsFolder)
            {
                var folder = (Folder)parentItem;

                if (!request.UserId.Equals(Guid.Empty))
                {
                    items = request.Recursive ?
                            folder.GetRecursiveChildren(user, query).ToList() :
                            folder.GetChildren(user, true).Where(Filter).ToList();
                }
                else
                {
                    items = request.Recursive ?
                            folder.GetRecursiveChildren(Filter) :
                            folder.Children.Where(Filter).ToList();
                }
            }
            else
            {
                items = new[] { parentItem }.Where(Filter).ToList();
            }

            var extractedItems = GetAllItems(request, items);

            var filteredItems = LibraryManager.Sort(extractedItems, user, request.GetOrderBy());

            var ibnItemsArray = filteredItems.ToList();

            IEnumerable <BaseItem> ibnItems = ibnItemsArray;

            var result = new QueryResult <BaseItemDto>
            {
                TotalRecordCount = ibnItemsArray.Count
            };

            if (request.StartIndex.HasValue || request.Limit.HasValue)
            {
                if (request.StartIndex.HasValue)
                {
                    ibnItems = ibnItems.Skip(request.StartIndex.Value);
                }

                if (request.Limit.HasValue)
                {
                    ibnItems = ibnItems.Take(request.Limit.Value);
                }
            }

            var tuples = ibnItems.Select(i => new Tuple <BaseItem, List <BaseItem> >(i, new List <BaseItem>()));

            var dtos = tuples.Select(i => DtoService.GetItemByNameDto(i.Item1, dtoOptions, i.Item2, user));

            result.Items = dtos.Where(i => i != null).ToArray();

            return(result);
        }
        /// <summary>
        /// Gets the specified request.
        /// </summary>
        /// <param name="request">The request.</param>
        /// <returns>Task{ItemsResult}.</returns>
        protected ItemsResult GetResult(GetItemsByName request)
        {
            User            user = null;
            BaseItem        parentItem;
            List <BaseItem> libraryItems;

            if (request.UserId.HasValue)
            {
                user         = UserManager.GetUserById(request.UserId.Value);
                parentItem   = string.IsNullOrEmpty(request.ParentId) ? user.RootFolder : LibraryManager.GetItemById(request.ParentId);
                libraryItems = user.RootFolder.GetRecursiveChildren(user).ToList();
            }
            else
            {
                parentItem   = string.IsNullOrEmpty(request.ParentId) ? LibraryManager.RootFolder : LibraryManager.GetItemById(request.ParentId);
                libraryItems = LibraryManager.RootFolder.GetRecursiveChildren().ToList();
            }

            IEnumerable <BaseItem> items;

            var excludeItemTypes = request.GetExcludeItemTypes();
            var includeItemTypes = request.GetIncludeItemTypes();
            var mediaTypes       = request.GetMediaTypes();

            Func <BaseItem, bool> filter = i => FilterItem(request, i, excludeItemTypes, includeItemTypes, mediaTypes);

            if (parentItem.IsFolder)
            {
                var folder = (Folder)parentItem;

                if (request.UserId.HasValue)
                {
                    items = request.Recursive ?
                            folder.GetRecursiveChildren(user, filter) :
                            folder.GetChildren(user, true).Where(filter);
                }
                else
                {
                    items = request.Recursive ?
                            folder.GetRecursiveChildren(filter) :
                            folder.Children.Where(filter);
                }
            }
            else
            {
                items = new[] { parentItem }.Where(filter);
            }

            var extractedItems = GetAllItems(request, items);

            var filteredItems = FilterItems(request, extractedItems, user);

            filteredItems = FilterByLibraryItems(request, filteredItems, user, libraryItems);

            filteredItems = LibraryManager.Sort(filteredItems, user, request.GetOrderBy(), request.SortOrder ?? SortOrder.Ascending).Cast <TItemType>();

            var ibnItemsArray = filteredItems.ToList();

            IEnumerable <TItemType> ibnItems = ibnItemsArray;

            var result = new ItemsResult
            {
                TotalRecordCount = ibnItemsArray.Count
            };

            if (request.StartIndex.HasValue || request.Limit.HasValue)
            {
                if (request.StartIndex.HasValue)
                {
                    ibnItems = ibnItems.Skip(request.StartIndex.Value);
                }

                if (request.Limit.HasValue)
                {
                    ibnItems = ibnItems.Take(request.Limit.Value);
                }
            }

            var tuples = ibnItems.Select(i => new Tuple <TItemType, List <BaseItem> >(i, i.GetTaggedItems(libraryItems).ToList()));

            var dtoOptions = GetDtoOptions(request);

            var dtos = tuples.Select(i => GetDto(i.Item1, user, dtoOptions, i.Item2));

            result.Items = dtos.Where(i => i != null).ToArray();

            return(result);
        }