FilterFieldExpressionFactory.cs

FilterFieldExpressionFactory.cs

    public static class FilterFieldExpressionFactory
    {
        public static Expression<Func<T, bool>> Create<T>(IEnumerable<FieldResult> filterFields) where T : class =>
            FilterExpressionFactory<T>.Create(filterFields);

        private static class FilterExpressionFactory<T> where T : class
        {
            private static Expression<Func<T, bool>> CreateFieldValue(FieldResult field, FieldValue fieldValue, ExpressionStarter<T> fieldPredicate) =>
                field.CriteriaType == CriteriaType.Is
                    ? CriteriaIs(field, fieldValue, fieldPredicate)
                    : CriteriaIsNot(field, fieldValue, fieldPredicate);

            private static Expression<Func<T, bool>> CreateCompositeFieldValue(FieldResult field, CompositeFieldValue compositeValue, ExpressionStarter<T> fieldPredicate)
            {
                foreach (var value in compositeValue.Values)
                    fieldPredicate = CreateFieldValue(field, value, fieldPredicate);

                return fieldPredicate;
            }

            private static Expression<Func<T, bool>> CriteriaIs(FieldResult field, FieldValue fieldValue, ExpressionStarter<T> fieldPredicate)
            {
                var expression = ExpressionFactory.True<T>(field.FieldName, fieldValue.Value);
                return FilterPredicate.Create(FilterType.Or, fieldPredicate, expression);
            }

            private static Expression<Func<T, bool>> CriteriaIsNot(FieldResult field, FieldValue fieldValue, ExpressionStarter<T> fieldPredicate)
            {
                var expression = ExpressionFactory.False<T>(field.FieldName, fieldValue.Value);
                return FilterPredicate.Create(FilterType.And, fieldPredicate, expression);
            }

            private static Expression<Func<T, bool>> CreateExpression(FieldResult field, FieldValue value, ExpressionStarter<T> fieldPredicate)
            {
                return value is CompositeFieldValue composite
                           ? CreateCompositeFieldValue(field, composite, fieldPredicate)
                           : CreateFieldValue(field, value, fieldPredicate);
            }

            public static Expression<Func<T, bool>> Create(IEnumerable<FieldResult> filterFields)
            {
                var predicate = PredicateBuilder.New<T>(true);
                foreach (var field in filterFields)
                {
                    var fieldPredicate = PredicateBuilder.New<T>(true);
                    foreach (var value in field.Filter.FieldValues.Where(x => x.Filter))
                        fieldPredicate = CreateExpression(field, value, fieldPredicate);

                    predicate = FilterPredicate.Create(FilterType.And, predicate, fieldPredicate);
                }

                return predicate;
            }
        }
    }