< Summary - Jellyfin

Information
Class: Emby.Server.Implementations.Library.SearchEngine
Assembly: Emby.Server.Implementations
File(s): /srv/git/jellyfin/Emby.Server.Implementations/Library/SearchEngine.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 91
Coverable lines: 91
Total lines: 199
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 50
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)100%210%
GetSearchHints(...)0%4260%
AddIfMissing(...)0%620%
GetSearchHints(...)0%1806420%

File(s)

/srv/git/jellyfin/Emby.Server.Implementations/Library/SearchEngine.cs

#LineLine coverage
 1#pragma warning disable CS1591
 2
 3using System;
 4using System.Collections.Generic;
 5using System.Linq;
 6using Jellyfin.Data.Entities;
 7using Jellyfin.Data.Enums;
 8using Jellyfin.Extensions;
 9using MediaBrowser.Controller.Dto;
 10using MediaBrowser.Controller.Entities;
 11using MediaBrowser.Controller.Library;
 12using MediaBrowser.Model.Querying;
 13using MediaBrowser.Model.Search;
 14
 15namespace Emby.Server.Implementations.Library
 16{
 17    public class SearchEngine : ISearchEngine
 18    {
 19        private readonly ILibraryManager _libraryManager;
 20        private readonly IUserManager _userManager;
 21
 22        public SearchEngine(ILibraryManager libraryManager, IUserManager userManager)
 23        {
 024            _libraryManager = libraryManager;
 025            _userManager = userManager;
 026        }
 27
 28        public QueryResult<SearchHintInfo> GetSearchHints(SearchQuery query)
 29        {
 030            User? user = null;
 031            if (!query.UserId.IsEmpty())
 32            {
 033                user = _userManager.GetUserById(query.UserId);
 34            }
 35
 036            var results = GetSearchHints(query, user);
 037            var totalRecordCount = results.Count;
 38
 039            if (query.StartIndex.HasValue)
 40            {
 041                results = results.GetRange(query.StartIndex.Value, totalRecordCount - query.StartIndex.Value);
 42            }
 43
 044            if (query.Limit.HasValue)
 45            {
 046                results = results.GetRange(0, Math.Min(query.Limit.Value, results.Count));
 47            }
 48
 049            return new QueryResult<SearchHintInfo>(
 050                query.StartIndex,
 051                totalRecordCount,
 052                results);
 53        }
 54
 55        private static void AddIfMissing(List<BaseItemKind> list, BaseItemKind value)
 56        {
 057            if (!list.Contains(value))
 58            {
 059                list.Add(value);
 60            }
 061        }
 62
 63        /// <summary>
 64        /// Gets the search hints.
 65        /// </summary>
 66        /// <param name="query">The query.</param>
 67        /// <param name="user">The user.</param>
 68        /// <returns>IEnumerable{SearchHintResult}.</returns>
 69        /// <exception cref="ArgumentException"><c>query.SearchTerm</c> is <c>null</c> or empty.</exception>
 70        private List<SearchHintInfo> GetSearchHints(SearchQuery query, User? user)
 71        {
 072            var searchTerm = query.SearchTerm;
 73
 074            ArgumentException.ThrowIfNullOrEmpty(searchTerm);
 75
 076            searchTerm = searchTerm.Trim().RemoveDiacritics();
 77
 078            var excludeItemTypes = query.ExcludeItemTypes.ToList();
 079            var includeItemTypes = query.IncludeItemTypes.ToList();
 80
 081            excludeItemTypes.Add(BaseItemKind.Year);
 082            excludeItemTypes.Add(BaseItemKind.Folder);
 83
 084            if (query.IncludeGenres && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Genre)))
 85            {
 086                if (!query.IncludeMedia)
 87                {
 088                    AddIfMissing(includeItemTypes, BaseItemKind.Genre);
 089                    AddIfMissing(includeItemTypes, BaseItemKind.MusicGenre);
 90                }
 91            }
 92            else
 93            {
 094                AddIfMissing(excludeItemTypes, BaseItemKind.Genre);
 095                AddIfMissing(excludeItemTypes, BaseItemKind.MusicGenre);
 96            }
 97
 098            if (query.IncludePeople && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Person)))
 99            {
 0100                if (!query.IncludeMedia)
 101                {
 0102                    AddIfMissing(includeItemTypes, BaseItemKind.Person);
 103                }
 104            }
 105            else
 106            {
 0107                AddIfMissing(excludeItemTypes, BaseItemKind.Person);
 108            }
 109
 0110            if (query.IncludeStudios && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.Studio)))
 111            {
 0112                if (!query.IncludeMedia)
 113                {
 0114                    AddIfMissing(includeItemTypes, BaseItemKind.Studio);
 115                }
 116            }
 117            else
 118            {
 0119                AddIfMissing(excludeItemTypes, BaseItemKind.Studio);
 120            }
 121
 0122            if (query.IncludeArtists && (includeItemTypes.Count == 0 || includeItemTypes.Contains(BaseItemKind.MusicArti
 123            {
 0124                if (!query.IncludeMedia)
 125                {
 0126                    AddIfMissing(includeItemTypes, BaseItemKind.MusicArtist);
 127                }
 128            }
 129            else
 130            {
 0131                AddIfMissing(excludeItemTypes, BaseItemKind.MusicArtist);
 132            }
 133
 0134            AddIfMissing(excludeItemTypes, BaseItemKind.CollectionFolder);
 0135            AddIfMissing(excludeItemTypes, BaseItemKind.Folder);
 0136            var mediaTypes = query.MediaTypes.ToList();
 137
 0138            if (includeItemTypes.Count > 0)
 139            {
 0140                excludeItemTypes.Clear();
 0141                mediaTypes.Clear();
 142            }
 143
 0144            var searchQuery = new InternalItemsQuery(user)
 0145            {
 0146                SearchTerm = searchTerm,
 0147                ExcludeItemTypes = excludeItemTypes.ToArray(),
 0148                IncludeItemTypes = includeItemTypes.ToArray(),
 0149                Limit = query.Limit,
 0150                IncludeItemsByName = !query.ParentId.HasValue,
 0151                ParentId = query.ParentId ?? Guid.Empty,
 0152                OrderBy = new[] { (ItemSortBy.SortName, SortOrder.Ascending) },
 0153                Recursive = true,
 0154
 0155                IsKids = query.IsKids,
 0156                IsMovie = query.IsMovie,
 0157                IsNews = query.IsNews,
 0158                IsSeries = query.IsSeries,
 0159                IsSports = query.IsSports,
 0160                MediaTypes = mediaTypes.ToArray(),
 0161
 0162                DtoOptions = new DtoOptions
 0163                {
 0164                    Fields = new ItemFields[]
 0165                    {
 0166                        ItemFields.AirTime,
 0167                        ItemFields.DateCreated,
 0168                        ItemFields.ChannelInfo,
 0169                        ItemFields.ParentId
 0170                    }
 0171                }
 0172            };
 173
 174            List<BaseItem> mediaItems;
 175
 0176            if (searchQuery.IncludeItemTypes.Length == 1 && searchQuery.IncludeItemTypes[0] == BaseItemKind.MusicArtist)
 177            {
 0178                if (!searchQuery.ParentId.IsEmpty())
 179                {
 0180                    searchQuery.AncestorIds = [searchQuery.ParentId];
 0181                    searchQuery.ParentId = Guid.Empty;
 182                }
 183
 0184                searchQuery.IncludeItemsByName = true;
 0185                searchQuery.IncludeItemTypes = Array.Empty<BaseItemKind>();
 0186                mediaItems = _libraryManager.GetAllArtists(searchQuery).Items.Select(i => i.Item).ToList();
 187            }
 188            else
 189            {
 0190                mediaItems = _libraryManager.GetItemList(searchQuery);
 191            }
 192
 0193            return mediaItems.Select(i => new SearchHintInfo
 0194            {
 0195                Item = i
 0196            }).ToList();
 197        }
 198    }
 199}