private Expression <Func <T, bool> > GetPropertyCondition <T>(WhereQueryProperty property, IEnumerable <PropertyInfo> propertyInfos, ParameterExpression parameterExpression) where T : class
{
var propertyInfo = propertyInfos.SingleOrDefault(p => p.Name.Equals(property.PropertyName));
if (propertyInfo == null)
{
return(null);
}
var propertyType = propertyInfo.PropertyType;
if (propertyInfo.PropertyType.ImplementsIEnumerable())
{
propertyType = propertyInfo.PropertyType.GetDataTypeFromIEnumerable();
}
var data = new ExpressionDataContainer
{
PropertyInfo = propertyInfo,
Parameter = parameterExpression,
Operator = property.Operator,
ConstantValue = _constantExpressions[propertyType.GetDataType()](property.SearchTerm, propertyType, property.Operator)
};
return(GetConditionComparableByProperty <T>(data));
}
private Expression <Func <T, bool> > GetMappingCondition <T>(WhereQueryProperty property, Expression <Func <T, object> > mappingExpression, Type expectedDataType = null) where T : class
{
var memberExpression = GetMemberExpression(mappingExpression);
if (memberExpression == null || (expectedDataType != null && memberExpression.Type != expectedDataType))
{
return(null);
}
var memberType = memberExpression.Type;
if (memberType.ImplementsIEnumerable())
{
memberType = memberType.GetDataTypeFromIEnumerable();
}
var data = new ExpressionDataContainer
{
Member = memberExpression,
Parameter = mappingExpression.Parameters.First(),
Operator = property.Operator,
ConstantValue = _constantExpressions[memberType.GetDataType()](property.SearchTerm, memberType, property.Operator)
};
return(GetConditionComparableByMemberExpression <T>(data));
}
private Expression <Func <T, bool> > BuildGlobalQueryCondition <T>(BuildQueryContainer <T> queryContainer) where T : class
{
var where = new List <Expression <Func <T, bool> > >();
var property = new WhereQueryProperty {
Operator = CompareOperator.Contains, SearchTerm = queryContainer.QueryParameters.SearchTerm
};
foreach (var propertyInfo in queryContainer.PropertyInfos)
{
property.PropertyName = propertyInfo.Name;
if (queryContainer.Mappings.ContainsKey(propertyInfo.Name))
{
where.AddRange(queryContainer.Mappings[propertyInfo.Name].Select(m => GetMappingCondition(property, m, _typeString)).Where(e => e != null).ToList());
}
else if (propertyInfo.PropertyType == _typeString)
{
var condition = GetPropertyCondition <T>(property, queryContainer.PropertyInfos, queryContainer.Parameter);
if (condition != null)
{
where.Add(condition);
}
}
}
return(where.Any() ? JoinOrExpressions(where) : null);
}
public static QueryProperty Where(this Query query, string expression)
{
var property = new WhereQueryProperty(query);
property.AddOperator(new QueryOperator("$where", string.Format("\" {0} \"", expression)));
query.AddProperty(property);
return property;
}
private Expression <Func <T, bool> > BuildGlobalQueryCondition <T>(BuildQueryContainer <T> queryContainer) where T : class
{
var where = new List <Expression <Func <T, bool> > >();
var searchTermParts = new[] { queryContainer.QueryParameters.SearchTerm };
if (_options.ContainsSearchSplitBySpace)
{
searchTermParts = queryContainer.QueryParameters.SearchTerm.Split(' ').Where(t => !t.IsNullOrEmpty()).ToArray();
}
var andExpressions = new List <Expression <Func <T, bool> > >();
foreach (var searchTermPart in searchTermParts)
{
var property = new WhereQueryProperty {
Operator = CompareOperator.Contains, SearchTerm = searchTermPart
};
var orExpressions = new List <Expression <Func <T, bool> > >();
foreach (var propertyInfo in queryContainer.PropertyInfos)
{
property.PropertyName = propertyInfo.Name;
if (queryContainer.Mappings.ContainsKey(propertyInfo.Name))
{
orExpressions.AddRange(queryContainer.Mappings[propertyInfo.Name].SelectMany(m => GetMappingCondition(property, m, _typeString)).Where(e => e != null).ToList());
}
else if (propertyInfo.PropertyType == _typeString && propertyInfo.GetCustomAttribute <QueryIgnoreAttribute>() == null)
{
var conditions = GetPropertyCondition <T>(property, queryContainer.PropertyInfos, queryContainer.Parameter);
if (conditions.Any())
{
orExpressions.AddRange(conditions);
}
}
}
foreach (var mapping in queryContainer.Mappings)
{
if (queryContainer.PropertyInfos.Any(propertyInfo => propertyInfo.Name == mapping.Key))
{
continue;
}
orExpressions.AddRange(mapping.Value.SelectMany(m => GetMappingCondition(property, m, _typeString)).Where(e => e != null).ToList());
}
if (orExpressions.Count > 0)
{
andExpressions.Add(JoinOrExpressions(orExpressions));
}
}
return(JoinAndExpressions(andExpressions));
}
public static QueryProperty Where(this Query query, string expression)
{
var property = new WhereQueryProperty(query);
property.AddOperator(new QueryOperator("$where", string.Format("\" {0} \"", expression)));
query.AddProperty(property);
return(property);
}
private IEnumerable <Expression <Func <T, bool> > > GetPropertyCondition <T>(WhereQueryProperty property, IEnumerable <PropertyInfo> propertyInfos, ParameterExpression parameterExpression) where T : class
{
var propertyInfo = propertyInfos.SingleOrDefault(p => p.Name.Equals(property.PropertyName));
if (propertyInfo == null || propertyInfo.GetCustomAttribute <QueryIgnoreAttribute>() != null)
{
return(Array.Empty <Expression <Func <T, bool> > >());
}
var propertyType = propertyInfo.PropertyType;
if (propertyInfo.PropertyType.ImplementsIEnumerable())
{
propertyType = propertyInfo.PropertyType.GetDataTypeFromIEnumerable();
}
var expression = new List <Expression <Func <T, bool> > >();
var searchTermParts = new[] { property.SearchTerm };
if (_options.ContainsSearchSplitBySpace && propertyType == _typeString && property.Operator == CompareOperator.Contains)
{
searchTermParts = property.SearchTerm.Split(' ').Where(t => !t.IsNullOrEmpty()).ToArray();
}
foreach (var searchTermPart in searchTermParts)
{
var dataType = propertyType.GetDataType();
if (dataType.IsEnum)
{
dataType = _typeEnum;
}
var data = new ExpressionDataContainer
{
PropertyInfo = propertyInfo,
Parameter = parameterExpression,
Operator = property.Operator,
ConstantValue = _constantExpressions[dataType](searchTermPart, propertyType, property.Operator, _options)
};
var condition = GetConditionComparableByProperty <T>(data);
if (condition != null)
{
expression.Add(condition);
}
}
return(expression);
}
private IList <Expression <Func <T, bool> > > GetMappingCondition <T>(WhereQueryProperty property, Expression <Func <T, object> > mappingExpression, Type expectedDataType = null) where T : class
{
var memberExpression = GetMemberExpression(mappingExpression);
if (memberExpression == null || (expectedDataType != null && memberExpression.Type != expectedDataType))
{
return(Array.Empty <Expression <Func <T, bool> > >());
}
var memberType = memberExpression.Type;
if (memberType.ImplementsIEnumerable())
{
memberType = memberType.GetDataTypeFromIEnumerable();
}
var expression = new List <Expression <Func <T, bool> > >();
var searchTermParts = new[] { property.SearchTerm };
if (_options.ContainsSearchSplitBySpace && memberType == _typeString && property.Operator == CompareOperator.Contains)
{
searchTermParts = property.SearchTerm.Split(' ').Where(t => !t.IsNullOrEmpty()).ToArray();
}
foreach (var searchTermPart in searchTermParts)
{
var dataType = memberType.GetDataType();
if (dataType.IsEnum)
{
dataType = _typeEnum;
}
var data = new ExpressionDataContainer
{
Member = memberExpression,
Parameter = mappingExpression.Parameters.First(),
Operator = property.Operator,
ConstantValue = _constantExpressions[dataType](searchTermPart, memberType, property.Operator, _options)
};
expression.Add(GetConditionComparableByMemberExpression <T>(data));
}
return(expression);
}
