/// <summary>
/// Get a query item by expression
/// </summary>
/// <param name="queryOperator">Connect operator</param>
/// <param name="expression">Condition expression</param>
/// <returns>IQueryItem object</returns>
internal static Tuple <QueryOperator, IQueryItem> GetExpressionQuery(QueryOperator queryOperator, Expression expression)
{
var nodeType = expression.NodeType;
ExpressionType queryNodeType = queryOperator == QueryOperator.OR ? ExpressionType.OrElse : ExpressionType.AndAlso;
if (ExpressionHelper.IsCompareNodeType(nodeType))
{
return(GetSingleExpressionQueryItem(queryNodeType, expression));
}
else if (ExpressionHelper.IsBoolNodeType(nodeType))
{
BinaryExpression binExpression = expression as BinaryExpression;
if (binExpression == null)
{
throw new EZNEWException("Expression is error");
}
IQuery query = QueryManager.Create();
var leftQuery = GetExpressionQuery(queryOperator, binExpression.Left);
if (leftQuery != null)
{
query.AddQueryItem(leftQuery.Item1, leftQuery.Item2);
}
QueryOperator rightQueryOperator = nodeType == ExpressionType.OrElse ? QueryOperator.OR : QueryOperator.AND;
var rightQuery = GetExpressionQuery(rightQueryOperator, binExpression.Right);
if (rightQuery != null)
{
query.AddQueryItem(rightQuery.Item1, rightQuery.Item2);
}
return(new Tuple <QueryOperator, IQueryItem>(queryOperator, query));
}
else if (nodeType == ExpressionType.Call)
{
return(GetCallExpressionQueryItem(queryOperator, expression));
}
else if (nodeType == ExpressionType.Not)
{
UnaryExpression unaryExpress = expression as UnaryExpression;
if (unaryExpress != null && unaryExpress.Operand is MethodCallExpression)
{
return(GetCallExpressionQueryItem(queryOperator, unaryExpress.Operand, true));
}
}
return(null);
}
/// <summary>
/// Add a condition with 'and'
/// </summary>
/// <typeparam name="TQueryModel">Query model</typeparam>
/// <param name="sourceQuery">Source query</param>
/// <param name="criteria">Criteria</param>
/// <returns>Return the newest IQuery object</returns>
public static IQuery And <TQueryModel>(this IQuery sourceQuery, Expression <Func <TQueryModel, bool> > criteria) where TQueryModel : IQueryModel <TQueryModel>
{
var expressQuery = ExpressionQueryHelper.GetExpressionQuery(QueryOperator.AND, criteria.Body);
if (expressQuery != null)
{
sourceQuery = sourceQuery.AddQueryItem(expressQuery.Item1, expressQuery.Item2);
}
return(sourceQuery);
}
/// <summary>
/// Add a condition with 'and'
/// </summary>
/// <param name="sourceQuery">Source query</param>
/// <param name="eachFieldConnectOperator">each field codition connect operator</param>
/// <param name="operator">Condition operator</param>
/// <param name="value">Value</param>
/// <param name="converter">Criteria converter</param>
/// <param name="fieldNames">Field names</param>
/// <returns>Return the newest IQuery object</returns>
public static IQuery And(this IQuery sourceQuery, QueryOperator eachFieldConnectOperator, CriteriaOperator @operator, dynamic value, ICriteriaConverter converter, params string[] fieldNames)
{
if (fieldNames.IsNullOrEmpty())
{
return(sourceQuery);
}
IQuery groupQuery = QueryManager.Create();
foreach (string field in fieldNames)
{
switch (eachFieldConnectOperator)
{
case QueryOperator.AND:
default:
groupQuery = And(groupQuery, field, @operator, value, converter);
break;
case QueryOperator.OR:
groupQuery = OrExtensions.Or(groupQuery, field, @operator, value, converter);
break;
}
}
return(sourceQuery.AddQueryItem(QueryOperator.AND, groupQuery));
}
/// <summary>
/// Add a condition with 'and'
/// </summary>
/// <param name="sourceQuery">Source query</param>
/// <param name="groupQuery">Group query condition</param>
/// <returns>Return the newest IQuery object</returns>
public static IQuery And(this IQuery sourceQuery, IQuery groupQuery)
{
return(sourceQuery.AddQueryItem(QueryOperator.AND, groupQuery));
}
