Simply code, moving to my PC

API/Data/Repositories/GenreRepository.cs

@@ -174,59 +174,32 @@ public class GenreRepository : IGenreRepository
         var ageRating = await _context.AppUser.GetUserAgeRestriction(userId);
 
         var allLibrariesCount =  await _context.Library.CountAsync();
-        var userLibs = await _context.Library
+        var userLibs = await _context.Library.GetUserLibraries(userId).ToListAsync();
-            .Includes(LibraryIncludes.AppUser)
-            .Where(lib => lib.AppUsers.Any(user => user.Id == userId))
-            .Select(lib => lib.Id)
-            .ToListAsync();
 
-        var query = _context.Genre.RestrictAgainstAgeRestriction(ageRating);
+        var seriesIds = await _context.Series.Where(s => userLibs.Contains(s.LibraryId)).Select(s => s.Id).ToListAsync();
 
-        IQueryable<BrowseGenreDto> finalQuery;
+        var query = _context.Genre
-        var seriesIds = _context.Series.Where(s => userLibs.Contains(s.LibraryId)).Select(s => s.Id);
+            .RestrictAgainstAgeRestriction(ageRating)
-        if (allLibrariesCount != userLibs.Count)
+            .WhereIf(allLibrariesCount != userLibs.Count,
-        {
+                genre => genre.Chapters.Any(cp => seriesIds.Contains(cp.Volume.SeriesId)) ||
-
+                         genre.SeriesMetadatas.Any(sm => seriesIds.Contains(sm.SeriesId)))
-            query = query.Where(s => s.Chapters.Any(cp => seriesIds.Contains(cp.Volume.SeriesId)) ||
+            .Select(g => new BrowseGenreDto
-                                     s.SeriesMetadatas.Any(sm => seriesIds.Contains(sm.SeriesId)));
-
-            finalQuery = query.Select(g => new BrowseGenreDto
             {
                 Id = g.Id,
                 Title = g.Title,
                 SeriesCount = g.SeriesMetadatas
-                        .Where(sm => seriesIds.Contains(sm.SeriesId))
+                    .Where(sm => allLibrariesCount == userLibs.Count || seriesIds.Contains(sm.SeriesId))
                     .RestrictAgainstAgeRestriction(ageRating)
                     .Distinct()
                     .Count(),
                 ChapterCount = g.Chapters
-                        .Where(cp => seriesIds.Contains(cp.Volume.SeriesId))
+                    .Where(cp => allLibrariesCount == userLibs.Count || seriesIds.Contains(cp.Volume.SeriesId))
-                        .RestrictAgainstAgeRestriction(ageRating)
-                        .Distinct()
-                        .Count()
-                })
-                .OrderBy(g => g.Title);
-        }
-        else
-        {
-            finalQuery = query.Select(g => new BrowseGenreDto
-                {
-                    Id = g.Id,
-                    Title = g.Title,
-                    SeriesCount = g.SeriesMetadatas
                     .RestrictAgainstAgeRestriction(ageRating)
                     .Distinct()
                     .Count(),
-                    ChapterCount = g.Chapters
-                        .RestrictAgainstAgeRestriction(ageRating)
-                        .Distinct()
-                        .Count()
             })
             .OrderBy(g => g.Title);
-        }
 
-
+        return await PagedList<BrowseGenreDto>.CreateAsync(query, userParams.PageNumber, userParams.PageSize);
-
-        return await PagedList<BrowseGenreDto>.CreateAsync(finalQuery, userParams.PageNumber, userParams.PageSize);
     }
 }

API/Data/Repositories/PersonRepository.cs

@@ -216,10 +216,8 @@ public class PersonRepository : IPersonRepository
 
     private async Task<IQueryable<BrowsePersonDto>> CreateFilteredPersonQueryable(int userId, BrowsePersonFilterDto filter, AgeRestriction ageRating)
     {
-        var libs = await _context.Library.Includes(LibraryIncludes.AppUser).ToListAsync();
+        var allLibrariesCount =  await _context.Library.CountAsync();
-        var libIds = libs.Select(l => l.Id).ToList();
+        var userLibs = await _context.Library.GetUserLibraries(userId).ToListAsync();
-        var userLibs = libs.Where(lib => lib.AppUsers.Any(user => user.Id == userId)).Select(lib => lib.Id).ToList();
-        var shouldLibRestrict = libIds.Count != userLibs.Count;
 
         var seriesIds = await _context.Series.Where(s => userLibs.Contains(s.LibraryId)).Select(s => s.Id).ToListAsync();
 
@@ -229,23 +227,17 @@ public class PersonRepository : IPersonRepository
         query = BuildPersonFilterQuery(userId, filter, query);
 
         // Apply restrictions
-        query = query.RestrictAgainstAgeRestriction(ageRating);
+        query = query.RestrictAgainstAgeRestriction(ageRating)
-
+            .WhereIf(allLibrariesCount != userLibs.Count,
-        if (shouldLibRestrict)
+                person => person.ChapterPeople.Any(cp => seriesIds.Contains(cp.Chapter.Volume.SeriesId)) ||
-        {
+                          person.SeriesMetadataPeople.Any(smp => seriesIds.Contains(smp.SeriesMetadata.SeriesId)));
-            query = query.Where(p => p.ChapterPeople.Any(cp => seriesIds.Contains(cp.Chapter.Volume.SeriesId)) ||
-                                     p.SeriesMetadataPeople.Any(smp => seriesIds.Contains(smp.SeriesMetadata.SeriesId)));
-        }
 
         // Apply sorting and limiting
         var sortedQuery = query.SortBy(filter.SortOptions);
 
         var limitedQuery = ApplyPersonLimit(sortedQuery, filter.LimitTo);
 
-        IQueryable<BrowsePersonDto> projectedQuery;
+        return limitedQuery.Select(p => new BrowsePersonDto
-        if (shouldLibRestrict)
-        {
-            projectedQuery = limitedQuery.Select(p => new BrowsePersonDto
         {
             Id = p.Id,
             Name = p.Name,
@@ -253,42 +245,19 @@ public class PersonRepository : IPersonRepository
             CoverImage = p.CoverImage,
             SeriesCount = p.SeriesMetadataPeople
                 .Select(smp => smp.SeriesMetadata)
-                    .Where(sm => seriesIds.Contains(sm.SeriesId))
+                .Where(sm => allLibrariesCount == userLibs.Count || seriesIds.Contains(sm.SeriesId))
                 .RestrictAgainstAgeRestriction(ageRating)
                 .Distinct()
                 .Count(),
             ChapterCount = p.ChapterPeople
                 .Select(chp => chp.Chapter)
-                    .Where(ch => seriesIds.Contains(ch.Volume.SeriesId))
+                .Where(ch => allLibrariesCount == userLibs.Count || seriesIds.Contains(ch.Volume.SeriesId))
-                    .RestrictAgainstAgeRestriction(ageRating)
-                    .Distinct()
-                    .Count()
-            });
-        }
-        else
-        {
-            projectedQuery = limitedQuery.Select(p => new BrowsePersonDto
-            {
-                Id = p.Id,
-                Name = p.Name,
-                Description = p.Description,
-                CoverImage = p.CoverImage,
-                SeriesCount = p.SeriesMetadataPeople
-                    .Select(smp => smp.SeriesMetadata)
                 .RestrictAgainstAgeRestriction(ageRating)
                 .Distinct()
                 .Count(),
-                ChapterCount = p.ChapterPeople
-                    .Select(chp => chp.Chapter)
-                    .RestrictAgainstAgeRestriction(ageRating)
-                    .Distinct()
-                    .Count()
         });
     }
 
-        return projectedQuery;
-    }
-
     private static IQueryable<Person> BuildPersonFilterQuery(int userId, BrowsePersonFilterDto filterDto, IQueryable<Person> query)
     {
         if (filterDto.Statements == null || filterDto.Statements.Count == 0) return query;

API/Data/Repositories/TagRepository.cs

@@ -111,57 +111,34 @@ public class TagRepository : ITagRepository
     {
         var ageRating = await _context.AppUser.GetUserAgeRestriction(userId);
 
-        var libs = await _context.Library.Includes(LibraryIncludes.AppUser).ToListAsync();
+        var allLibrariesCount =  await _context.Library.CountAsync();
-        var userLibs = libs.Where(lib => lib.AppUsers.Any(user => user.Id == userId))
+        var userLibs = await _context.Library.GetUserLibraries(userId).ToListAsync();
-            .Select(lib => lib.Id).ToList();
 
-        var query = _context.Tag.RestrictAgainstAgeRestriction(ageRating);
-
-        IQueryable<BrowseTagDto> finalQuery;
-        if (userLibs.Count != libs.Count)
-        {
         var seriesIds = _context.Series.Where(s => userLibs.Contains(s.LibraryId)).Select(s => s.Id);
-            query = query.Where(tag => tag.Chapters.Any(cp => seriesIds.Contains(cp.Volume.SeriesId)) ||
-                                       tag.SeriesMetadatas.Any(sm => seriesIds.Contains(sm.SeriesId)));
 
-            finalQuery = query
+        var query = _context.Tag
+            .RestrictAgainstAgeRestriction(ageRating)
+            .WhereIf(userLibs.Count != allLibrariesCount,
+                tag => tag.Chapters.Any(cp => seriesIds.Contains(cp.Volume.SeriesId)) ||
+                       tag.SeriesMetadatas.Any(sm => seriesIds.Contains(sm.SeriesId)))
             .Select(g => new BrowseTagDto
             {
                 Id = g.Id,
                 Title = g.Title,
                 SeriesCount = g.SeriesMetadatas
-                        .Where(sm => seriesIds.Contains(sm.SeriesId))
+                    .Where(sm => allLibrariesCount == userLibs.Count || seriesIds.Contains(sm.SeriesId))
                     .RestrictAgainstAgeRestriction(ageRating)
                     .Distinct()
                     .Count(),
                 ChapterCount = g.Chapters
-                        .Where(ch => seriesIds.Contains(ch.Volume.SeriesId))
+                    .Where(ch => allLibrariesCount == userLibs.Count || seriesIds.Contains(ch.Volume.SeriesId))
                     .RestrictAgainstAgeRestriction(ageRating)
                     .Distinct()
                     .Count()
             })
             .OrderBy(g => g.Title);
-        }
-        else
-        {
-            finalQuery = query
-                .Select(g => new BrowseTagDto
-                {
-                    Id = g.Id,
-                    Title = g.Title,
-                    SeriesCount = g.SeriesMetadatas
-                        .RestrictAgainstAgeRestriction(ageRating)
-                        .Distinct()
-                        .Count(),
-                    ChapterCount = g.Chapters
-                        .RestrictAgainstAgeRestriction(ageRating)
-                        .Distinct()
-                        .Count()
-                })
-                .OrderBy(g => g.Title);
-        }
 
-        return await PagedList<BrowseTagDto>.CreateAsync(finalQuery, userParams.PageNumber, userParams.PageSize);
+        return await PagedList<BrowseTagDto>.CreateAsync(query, userParams.PageNumber, userParams.PageSize);
     }
 
     public async Task<IList<Tag>> GetAllTagsAsync()

API/Extensions/QueryExtensions/RestrictByLibraryExtensions.cs

@@ -1,14 +1,9 @@
-using System.Collections.Generic;
+using System.Linq;
-using System.Linq;
 using API.Entities;
 using API.Entities.Person;
 
 namespace API.Extensions.QueryExtensions;
 
-// TODO: Refactor with IQueryable userLibs? But then I can't do the allLibs check?
-/// <summary>
-/// Optionally pass ids of all libraries, will then be smart and not restrict if the person has access to all
-/// </summary>
 public static class RestrictByLibraryExtensions
 {