AZEN-SGG/Kavita
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Polish 6 (#3371)

Browse source
This commit is contained in:
Joe Milazzo 2024-11-16 09:20:28 -06:00 • committed by GitHub
parent 6a75291a67
commit c849eff33e
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
7 changed files with 190 additions and 35 deletions
Download patch file Download diff file Expand all files Collapse all files

52
API/Extensions/QueryExtensions/Filtering/SeriesFilter.cs
View file

@ -167,6 +167,7 @@ public static class SeriesFilter
throw new ArgumentOutOfRangeException(nameof(comparison), comparison, null);
}
}
public static IQueryable<Series> HasAverageReadTime(this IQueryable<Series> queryable, bool condition,
FilterComparison comparison, int avgReadTime)
{
@ -175,17 +176,17 @@ public static class SeriesFilter
switch (comparison)
{
case FilterComparison.NotEqual:
return queryable.Where(s => s.AvgHoursToRead != avgReadTime);
return queryable.WhereNotEqual(s => s.AvgHoursToRead, avgReadTime);
case FilterComparison.Equal:
return queryable.Where(s => s.AvgHoursToRead == avgReadTime);
return queryable.WhereEqual(s => s.AvgHoursToRead, avgReadTime);
case FilterComparison.GreaterThan:
return queryable.Where(s => s.AvgHoursToRead > avgReadTime);
return queryable.WhereGreaterThan(s => s.AvgHoursToRead, avgReadTime);
case FilterComparison.GreaterThanEqual:
return queryable.Where(s => s.AvgHoursToRead >= avgReadTime);
return queryable.WhereGreaterThanOrEqual(s => s.AvgHoursToRead, avgReadTime);
case FilterComparison.LessThan:
return queryable.Where(s => s.AvgHoursToRead < avgReadTime);
return queryable.WhereLessThan(s => s.AvgHoursToRead, avgReadTime);
case FilterComparison.LessThanEqual:
return queryable.Where(s => s.AvgHoursToRead <= avgReadTime);
return queryable.WhereLessThanOrEqual(s => s.AvgHoursToRead, avgReadTime);
case FilterComparison.Contains:
case FilterComparison.Matches:
case FilterComparison.NotContains:
@ -257,29 +258,29 @@ public static class SeriesFilter
Series = s,
Percentage = s.Progress
.Where(p => p != null && p.AppUserId == userId)
.Sum(p => p != null ? (p.PagesRead * 1.0f / s.Pages) : 0) * 100
.Sum(p => p != null ? (p.PagesRead * 1.0f / s.Pages) : 0f) * 100f
})
.AsSplitQuery();
switch (comparison)
{
case FilterComparison.Equal:
subQuery = subQuery.Where(s => Math.Abs(s.Percentage - readProgress) < FloatingPointTolerance);
subQuery = subQuery.WhereEqual(s => s.Percentage, readProgress);
break;
case FilterComparison.GreaterThan:
subQuery = subQuery.Where(s => s.Percentage > readProgress);
subQuery = subQuery.WhereGreaterThan(s => s.Percentage, readProgress);
break;
case FilterComparison.GreaterThanEqual:
subQuery = subQuery.Where(s => s.Percentage >= readProgress);
subQuery = subQuery.WhereGreaterThanOrEqual(s => s.Percentage, readProgress);
break;
case FilterComparison.LessThan:
subQuery = subQuery.Where(s => s.Percentage < readProgress);
subQuery = subQuery.WhereLessThan(s => s.Percentage, readProgress);
break;
case FilterComparison.LessThanEqual:
subQuery = subQuery.Where(s => s.Percentage <= readProgress);
subQuery = subQuery.WhereLessThanOrEqual(s => s.Percentage, readProgress);
break;
case FilterComparison.NotEqual:
subQuery = subQuery.Where(s => Math.Abs(s.Percentage - readProgress) > FloatingPointTolerance);
subQuery = subQuery.WhereNotEqual(s => s.Percentage, readProgress);
break;
case FilterComparison.IsEmpty:
case FilterComparison.Matches:
@ -306,7 +307,6 @@ public static class SeriesFilter
{
if (!condition) return queryable;
var subQuery = queryable
.Where(s => s.ExternalSeriesMetadata != null)
.Include(s => s.ExternalSeriesMetadata)
@ -316,27 +316,27 @@ public static class SeriesFilter
AverageRating = s.ExternalSeriesMetadata.AverageExternalRating
})
.AsSplitQuery()
.AsEnumerable();
.AsQueryable();
switch (comparison)
{
case FilterComparison.Equal:
subQuery = subQuery.Where(s => Math.Abs(s.AverageRating - rating) < FloatingPointTolerance);
subQuery = subQuery.WhereEqual(s => s.AverageRating, rating);
break;
case FilterComparison.GreaterThan:
subQuery = subQuery.Where(s => s.AverageRating > rating);
subQuery = subQuery.WhereGreaterThan(s => s.AverageRating, rating);
break;
case FilterComparison.GreaterThanEqual:
subQuery = subQuery.Where(s => s.AverageRating >= rating);
subQuery = subQuery.WhereGreaterThanOrEqual(s => s.AverageRating, rating);
break;
case FilterComparison.LessThan:
subQuery = subQuery.Where(s => s.AverageRating < rating);
subQuery = subQuery.WhereLessThan(s => s.AverageRating, rating);
break;
case FilterComparison.LessThanEqual:
subQuery = subQuery.Where(s => s.AverageRating <= rating);
subQuery = subQuery.WhereLessThanOrEqual(s => s.AverageRating, rating);
break;
case FilterComparison.NotEqual:
subQuery = subQuery.Where(s => Math.Abs(s.AverageRating - rating) > FloatingPointTolerance);
subQuery = subQuery.WhereNotEqual(s => s.AverageRating, rating);
break;
case FilterComparison.Matches:
case FilterComparison.Contains:
@ -534,21 +534,21 @@ public static class SeriesFilter
{
case FilterComparison.Equal:
case FilterComparison.Contains:
return queryable.Where(s => s.Metadata.People.Any(p => people.Contains(p.PersonId)));
return queryable.Where(s => s.Metadata.People.Any(p => people.Contains(p.PersonId) && p.Role == role));
case FilterComparison.NotEqual:
case FilterComparison.NotContains:
return queryable.Where(s => s.Metadata.People.All(t => !people.Contains(t.PersonId)));
return queryable.Where(s => s.Metadata.People.All(p => !people.Contains(p.PersonId) || p.Role != role));
case FilterComparison.MustContains:
// Deconstruct and do a Union of a bunch of where statements since this doesn't translate
var queries = new List<IQueryable<Series>>()
{
queryable
};
queries.AddRange(people.Select(gId => queryable.Where(s => s.Metadata.People.Any(p => p.PersonId == gId))));
queries.AddRange(people.Select(personId =>
queryable.Where(s => s.Metadata.People.Any(p => p.PersonId == personId && p.Role == role))));
return queries.Aggregate((q1, q2) => q1.Intersect(q2));
case FilterComparison.IsEmpty:
// Check if there are no people with specific roles (e.g., Writer, Penciller, etc.)
// Ensure no person with the given role exists
return queryable.Where(s => s.Metadata.People.All(p => p.Role != role));
case FilterComparison.GreaterThan:
case FilterComparison.GreaterThanEqual:

136
API/Extensions/QueryExtensions/QueryableExtensions.cs
View file

@ -16,6 +16,8 @@ namespace API.Extensions.QueryExtensions;
public static class QueryableExtensions
{
private const float DefaultTolerance = 0.001f;
public static Task<AgeRestriction> GetUserAgeRestriction(this DbSet<AppUser> queryable, int userId)
{
if (userId < 1)
@ -125,6 +127,140 @@ public static class QueryableExtensions
return queryable.Where(lambda);
}
public static IQueryable<T> WhereGreaterThan<T>(this IQueryable<T> source,
Expression<Func<T, float>> selector,
float value,
float tolerance = DefaultTolerance)
{
var parameter = selector.Parameters[0];
var propertyAccess = selector.Body;
// Absolute difference comparison: (propertyAccess - value) > tolerance
var difference = Expression.Subtract(propertyAccess, Expression.Constant(value));
var absoluteDifference = Expression.Condition(
Expression.LessThan(difference, Expression.Constant(0f)),
Expression.Negate(difference),
difference);
var greaterThanExpression = Expression.GreaterThan(propertyAccess, Expression.Constant(value));
var toleranceExpression = Expression.GreaterThan(absoluteDifference, Expression.Constant(tolerance));
var combinedExpression = Expression.AndAlso(greaterThanExpression, toleranceExpression);
var lambda = Expression.Lambda<Func<T, bool>>(combinedExpression, parameter);
return source.Where(lambda);
}
public static IQueryable<T> WhereGreaterThanOrEqual<T>(this IQueryable<T> source,
Expression<Func<T, float>> selector,
float value,
float tolerance = DefaultTolerance)
{
var parameter = selector.Parameters[0];
var propertyAccess = selector.Body;
var difference = Expression.Subtract(propertyAccess, Expression.Constant(value));
var absoluteDifference = Expression.Condition(
Expression.LessThan(difference, Expression.Constant(0f)),
Expression.Negate(difference),
difference);
var greaterThanOrEqualExpression = Expression.GreaterThanOrEqual(propertyAccess, Expression.Constant(value));
var toleranceExpression = Expression.GreaterThanOrEqual(absoluteDifference, Expression.Constant(tolerance));
var combinedExpression = Expression.AndAlso(greaterThanOrEqualExpression, toleranceExpression);
var lambda = Expression.Lambda<Func<T, bool>>(combinedExpression, parameter);
return source.Where(lambda);
}
public static IQueryable<T> WhereLessThan<T>(this IQueryable<T> source,
Expression<Func<T, float>> selector,
float value,
float tolerance = DefaultTolerance)
{
var parameter = selector.Parameters[0];
var propertyAccess = selector.Body;
var difference = Expression.Subtract(propertyAccess, Expression.Constant(value));
var absoluteDifference = Expression.Condition(
Expression.LessThan(difference, Expression.Constant(0f)),
Expression.Negate(difference),
difference);
var lessThanExpression = Expression.LessThan(propertyAccess, Expression.Constant(value));
var toleranceExpression = Expression.LessThan(absoluteDifference, Expression.Constant(tolerance));
var combinedExpression = Expression.AndAlso(lessThanExpression, toleranceExpression);
var lambda = Expression.Lambda<Func<T, bool>>(combinedExpression, parameter);
return source.Where(lambda);
}
public static IQueryable<T> WhereLessThanOrEqual<T>(this IQueryable<T> source,
Expression<Func<T, float>> selector,
float value,
float tolerance = DefaultTolerance)
{
var parameter = selector.Parameters[0];
var propertyAccess = selector.Body;
var difference = Expression.Subtract(propertyAccess, Expression.Constant(value));
var absoluteDifference = Expression.Condition(
Expression.LessThan(difference, Expression.Constant(0f)),
Expression.Negate(difference),
difference);
var lessThanOrEqualExpression = Expression.LessThanOrEqual(propertyAccess, Expression.Constant(value));
var toleranceExpression = Expression.LessThanOrEqual(absoluteDifference, Expression.Constant(tolerance));
var combinedExpression = Expression.AndAlso(lessThanOrEqualExpression, toleranceExpression);
var lambda = Expression.Lambda<Func<T, bool>>(combinedExpression, parameter);
return source.Where(lambda);
}
public static IQueryable<T> WhereEqual<T>(this IQueryable<T> source,
Expression<Func<T, float>> selector,
float value,
float tolerance = DefaultTolerance)
{
var parameter = selector.Parameters[0];
var propertyAccess = selector.Body;
// Absolute difference comparison: Math.Abs(propertyAccess - value) < tolerance
var difference = Expression.Subtract(propertyAccess, Expression.Constant(value));
var absoluteDifference = Expression.Condition(
Expression.LessThan(difference, Expression.Constant(0f)),
Expression.Negate(difference),
difference);
var toleranceExpression = Expression.LessThan(absoluteDifference, Expression.Constant(tolerance));
var lambda = Expression.Lambda<Func<T, bool>>(toleranceExpression, parameter);
return source.Where(lambda);
}
public static IQueryable<T> WhereNotEqual<T>(this IQueryable<T> source,
Expression<Func<T, float>> selector,
float value,
float tolerance = DefaultTolerance)
{
var parameter = selector.Parameters[0];
var propertyAccess = selector.Body;
var difference = Expression.Subtract(propertyAccess, Expression.Constant(value));
var absoluteDifference = Expression.Condition(
Expression.LessThan(difference, Expression.Constant(0f)),
Expression.Negate(difference),
difference);
var toleranceExpression = Expression.GreaterThan(absoluteDifference, Expression.Constant(tolerance));
var lambda = Expression.Lambda<Func<T, bool>>(toleranceExpression, parameter);
return source.Where(lambda);
}
/// <summary>
/// Performs a WhereLike that ORs multiple fields
/// </summary>