public override Expression <Func <Job, bool> > Build(JobsQueryParameter parameter)
{
if (parameter.Category > 0)
{
QueryExpression = QueryExpression.And(x => x.CategoryId == parameter.Category);
}
if (parameter.HireType > 0)
{
QueryExpression = QueryExpression.And(x => x.HireTypeId == parameter.HireType);
}
if (parameter.OnlyRemote)
{
QueryExpression = QueryExpression.And(x => x.IsRemote);
}
if (!string.IsNullOrWhiteSpace(parameter.Title))
{
QueryExpression = QueryExpression.And(x => x.Title.Contains(parameter.Title));
}
if (!string.IsNullOrWhiteSpace(parameter.Description))
{
QueryExpression = QueryExpression.And(x => x.Description.Contains(parameter.Description));
}
if (!string.IsNullOrWhiteSpace(parameter.HowToApply))
{
QueryExpression = QueryExpression.And(x => x.HowToApply.Contains(parameter.HowToApply));
}
return(QueryExpression);
}
private LinqQueryExpression <TEntity> HasFlagCall <TEntity>(MethodCallExpression methodCallExpression,
ExpressionConversionVisitor <TEntity> expressionConverter)
where TEntity : class
{
var expression = expressionConverter.Visit(methodCallExpression.Arguments[1]) as LinqQueryExpression <TEntity>;
var value = expressionConverter.Visit(methodCallExpression.Arguments[2]) as LinqQueryExpression <TEntity>;
return(new LinqQueryExpression <TEntity>(
QueryExpression.AreEqual(
QueryExpression.And(expression.QueryExpression, value.QueryExpression),
value.QueryExpression
),
(expression.JoinBuilders ?? JoinBuilder <TEntity> .Empty).Concat(
value.JoinBuilders ?? JoinBuilder <TEntity> .Empty
)));
}
protected override Expression VisitBinary(BinaryExpression node)
{
var left = Visit(node.Left) as LinqQueryExpression <TEntity>;
if (left == null)
{
throw new InvalidOperationException("Couldn't convert expression to SQL query expression.");
}
var right = Visit(node.Right) as LinqQueryExpression <TEntity>;
if (right == null)
{
throw new InvalidOperationException("Couldn't convert expression to SQL query expression.");
}
var leftExpression = left.QueryExpression;
var rightExpression = right.QueryExpression;
switch (node.NodeType)
{
case ExpressionType.AddChecked:
case ExpressionType.Add:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Add(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.SubtractChecked:
case ExpressionType.Subtract:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Subtract(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.MultiplyChecked:
case ExpressionType.Multiply:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Multiply(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Divide:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Divide(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.And:
return(new LinqQueryExpression <TEntity>(
QueryExpression.And(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.ExclusiveOr:
return(new LinqQueryExpression <TEntity>(
QueryExpression.ExclusiveOr(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Or:
return(new LinqQueryExpression <TEntity>(
QueryExpression.Or(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.AndAlso:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AndAlso(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.OrElse:
return(new LinqQueryExpression <TEntity>(
QueryExpression.OrElse(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.Equal:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AreEqual(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.NotEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.AreNotEqual(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.GreaterThan:
return(new LinqQueryExpression <TEntity>(
QueryExpression.GreaterThan(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.GreaterThanOrEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.GreaterThanOrEqualTo(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.LessThan:
return(new LinqQueryExpression <TEntity>(
QueryExpression.LessThan(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
case ExpressionType.LessThanOrEqual:
return(new LinqQueryExpression <TEntity>(
QueryExpression.LessThanOrEqualTo(leftExpression, rightExpression),
ConcatJoinBuilders(left.JoinBuilders, right.JoinBuilders)
));
default:
throw new Exception($"Unsupported binary node type '{node.NodeType}'.");
}
}