Use new filter on ef

back/src/Kyoo.Abstractions/Utility/ExpressionParameterReplacer.cs

@@ -0,0 +1,50 @@
+// Kyoo - A portable and vast media library solution.
+// Copyright (c) Kyoo.
+//
+// See AUTHORS.md and LICENSE file in the project root for full license information.
+//
+// Kyoo is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// any later version.
+//
+// Kyoo is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with Kyoo. If not, see <https://www.gnu.org/licenses/>.
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Linq.Expressions;
+
+namespace Kyoo.Utils;
+
+public sealed class ExpressionArgumentReplacer : ExpressionVisitor
+{
+	private readonly Dictionary<ParameterExpression, Expression> _mapping;
+
+	public ExpressionArgumentReplacer(Dictionary<ParameterExpression, Expression> dict)
+	{
+		_mapping = dict;
+	}
+
+	protected override Expression VisitParameter(ParameterExpression node)
+	{
+		if (_mapping.TryGetValue(node, out Expression? mappedArgument))
+			return Visit(mappedArgument);
+		return VisitParameter(node);
+	}
+
+	public static Expression ReplaceParams(Expression expression, IEnumerable<ParameterExpression> epxParams, params ParameterExpression[] param)
+	{
+		ExpressionArgumentReplacer replacer = new(
+			epxParams
+				.Zip(param)
+				.ToDictionary(x => x.First, x => x.Second as Expression)
+		);
+		return replacer.Visit(expression);
+	}
+}

back/src/Kyoo.Core/Controllers/Repositories/LocalRepository.cs

@@ -115,7 +115,30 @@ namespace Kyoo.Core.Controllers
 
 		protected static Expression<Func<T, bool>> ParseFilter(Filter<T>? filter)
 		{
-			throw new NotImplementedException();
+			if (filter == null)
+				return x => true;
+
+			ParameterExpression x = Expression.Parameter(typeof(T), "x");
+
+			Expression Parse(Filter<T> f)
+			{
+				return f switch
+				{
+					Filter<T>.And(var first, var second) => Expression.AndAlso(Parse(first), Parse(second)),
+					Filter<T>.Or(var first, var second) => Expression.OrElse(Parse(first), Parse(second)),
+					Filter<T>.Not(var inner) => Expression.Not(Parse(inner)),
+					Filter<T>.Eq(var property, var value) => Expression.Equal(Expression.Property(x, property), Expression.Constant(value)),
+					Filter<T>.Ne(var property, var value) => Expression.NotEqual(Expression.Property(x, property), Expression.Constant(value)),
+					Filter<T>.Gt(var property, var value) => Expression.GreaterThan(Expression.Property(x, property), Expression.Constant(value)),
+					Filter<T>.Ge(var property, var value) => Expression.GreaterThanOrEqual(Expression.Property(x, property), Expression.Constant(value)),
+					Filter<T>.Lt(var property, var value) => Expression.LessThan(Expression.Property(x, property), Expression.Constant(value)),
+					Filter<T>.Le(var property, var value) => Expression.LessThanOrEqual(Expression.Property(x, property), Expression.Constant(value)),
+					Filter<T>.Lambda(var lambda) => ExpressionArgumentReplacer.ReplaceParams(lambda.Body, lambda.Parameters, x),
+				};
+			}
+
+			Expression body = Parse(filter);
+			return Expression.Lambda<Func<T, bool>>(body, x);
 		}
 
 		private static Func<Expression, Expression, BinaryExpression> _GetComparisonExpression(