duper builder

using System;
using System.Linq.Expressions;
using System.Reflection;
using ETR.S7.Groups.AgentRequests.Core;
using ETR.S7.Groups.AgentRequests.Domain;
using ETR.S7.Groups.AgentRequests.Features.AgentRequests.Queries;

namespace ETR.S7.Groups.AgentRequests.Features
{
    internal class Client
    {
        public static void Test()
        {
            var filter = new GetAgentRequestsRegistry.Query();
            var qb = new QueryBuilder<AgentRequest>();

            var query = qb
                    .For(x => x.AddedDate)
                    .LessThan(filter.AddedDateLessThan)
                    .Between(filter.AddedDateGreaterThan, filter.AddedDateLessThan)
                    .For(x => x.Title)
                    .Contains(filter.Title)
                    .Predicate
                ;
        }
    }

    public class QueryBuilder<TEntity>
    {
        public QueryBuilder()
        {
            Predicate = PredicateBuilder.True<TEntity>();
        }

        public Expression<Func<TEntity, bool>> Predicate { get; private set; }

        public Member<TMember> For<TMember>(Expression<Func<TEntity, TMember>> destinationMember)
        {
            return new Member<TMember>(destinationMember, this);
        }

        public class Member<TMember>
        {
            private readonly QueryBuilder<TEntity> _parent;

            public Member(Expression<Func<TEntity, TMember>> destinationMember, QueryBuilder<TEntity> parent)
            {
                _parent = parent;
                DestinationMember = destinationMember;
            }

            public Expression<Func<TEntity, bool>> Predicate => _parent.Predicate;

            public Expression<Func<TEntity, TMember>> DestinationMember { get; }

            public Member<TMember> And(Expression<Func<TEntity, bool>> expr2)
            {
                _parent.Predicate = _parent.Predicate.And(expr2);
                return this;
            }

            public Member<TNextMember> For<TNextMember>(Expression<Func<TEntity, TNextMember>> destinationMember)
            {
                return _parent.For(destinationMember);
            }
        }
    }

    public static class MemberQueryBuilderExtensions
    {
        private static readonly MethodInfo StringContainsMethod =
            typeof(string).GetMethod(@"Contains", BindingFlags.Instance |
                                                  BindingFlags.Public, null, new[] {typeof(string)}, null);

        public static QueryBuilder<TEntity>.Member<DateTimeOffset?> LessThan<TEntity>(
            this QueryBuilder<TEntity>.Member<DateTimeOffset?> builder, DateTimeOffset? value)
        {
            if (value == null)
            {
                return builder;
            }

            var parameter = Expression.Parameter(typeof(TEntity));
            var filterValueAccess = Expression.Constant(value, value.GetType());
            var body = Expression.LessThan(builder.DestinationMember, filterValueAccess);
            var result = Expression.Lambda<Func<TEntity, bool>>(body, parameter);

            return builder.And(result);
        }

        public static QueryBuilder<TEntity>.Member<DateTimeOffset?> LessThanOrEqual<TEntity>(
            this QueryBuilder<TEntity>.Member<DateTimeOffset?> builder, DateTimeOffset? value)
        {
            if (value == null)
            {
                return builder;
            }

            var parameter = Expression.Parameter(typeof(TEntity));
            var constant = Expression.Constant(value, value.GetType());
            var body = Expression.LessThanOrEqual(builder.DestinationMember, constant);
            var result = Expression.Lambda<Func<TEntity, bool>>(body, parameter);

            return builder.And(result);
        }

        public static QueryBuilder<TEntity>.Member<DateTimeOffset?> GreaterThanOrEqual<TEntity>(
            this QueryBuilder<TEntity>.Member<DateTimeOffset?> builder, DateTimeOffset? value)
        {
            if (value == null)
            {
                return builder;
            }

            var parameter = Expression.Parameter(typeof(TEntity));
            var constant = Expression.Constant(value, value.GetType());
            var body = Expression.GreaterThanOrEqual(builder.DestinationMember, constant);
            var result = Expression.Lambda<Func<TEntity, bool>>(body, parameter);

            return builder.And(result);
        }

        public static QueryBuilder<TEntity>.Member<string> Contains<TEntity>(
            this QueryBuilder<TEntity>.Member<string> builder, string value)
        {
            if (value == null)
            {
                return builder;
            }

            var parameter = Expression.Parameter(typeof(TEntity));
            var constant = Expression.Constant(value, value.GetType());
            var body = Expression.Call(builder.DestinationMember, StringContainsMethod, constant);
            ;
            var result = Expression.Lambda<Func<TEntity, bool>>(body, parameter);

            return builder.And(result);
        }

        public static QueryBuilder<TEntity>.Member<DateTimeOffset?> Between<TEntity>(
            this QueryBuilder<TEntity>.Member<DateTimeOffset?> builder, DateTimeOffset? min, DateTimeOffset? max)
        {
            if (max != null)
            {
                builder.LessThanOrEqual(max);
            }

            if (min != null)
            {
                builder.GreaterThanOrEqual(min);
            }

            return builder;
        }
    }
}