String contains specification for nested properties - asp.net-core

Question

I'm trying to implement a contains specification for nested properties. I am currently working off a contains specification below that only supports a simple property.
For an object structure like below and applying the specification to the Manager Entity.
public class Manager
{
public string Name { get; set; }
public Department Department { get; set; }
public IList<Employee> Employees { get; set; }
}
public class Department
{
public string Name { get; set; }
}
public class Employee
{
public string Name { get; set; }
}
It is able to support a filter like below.
[
{
"Name",
"John"
}
]
The problem comes when I need to support a more complicated query like below.
[
{
"Employees.Name",
"Jake"
}
]
I think the specification will also have to behave different for a filter like this because it is not looking into a collection and just a single object.
[
{
"Department.Name",
"Accounting",
}
]
The contains specification that I currently have now
private static Expression<Func<T, bool>> CreateExpression(IDictionary<string, string> filter)
{
var type = typeof(T);
var parameterExpression = Expression.Parameter(typeof(T));
var aggregatedExpression = filter.Aggregate((Expression)null, (agg, pair) =>
{
var propertyInfo = type
.GetProperties()
.FirstOrDefault(t => t.Name.Equals(pair.Key, StringComparison.InvariantCultureIgnoreCase));
if (propertyInfo == null)
{
throw new Exception("PropertyInfo was not found.");
}
// Call to string on value if property is of the listed property types
var propertyExpression = (Expression)Expression.Property(parameterExpression, propertyInfo);
if (propertyInfo.PropertyType == typeof(long) ||
propertyInfo.PropertyType == typeof(long?) ||
propertyInfo.PropertyType == typeof(int) ||
propertyInfo.PropertyType == typeof(int?) ||
propertyInfo.PropertyType == typeof(DateTime) ||
propertyInfo.PropertyType == typeof(DateTime?) ||
propertyInfo.PropertyType == typeof(Guid) ||
propertyInfo.PropertyType == typeof(Guid?))
{
var toStringMethod = propertyExpression.Type.GetMethod(nameof(ToString), new Type[] { });
if (toStringMethod != null)
{
propertyExpression = Expression.Call(propertyExpression, toStringMethod);
}
}
var containsMethod = propertyExpression.Type.GetMethod(nameof(Queryable.Contains), new[] { propertyExpression.Type });
if (containsMethod == null)
{
throw new Exception("Contains method is not found.");
}
// Call contains on the property (i.e. Name.Contains("John")
var expression = Expression.Call(propertyExpression, containsMethod, Expression.Constant(pair.Value));
// Multiple Contains to be aggregated into OrElse
agg = agg == null ? expression : (Expression)Expression.OrElse(agg, expression);
return agg;
});
return Expression.Lambda<Func<T, bool>>(aggregatedExpression, parameterExpression);
}