public void AddFilter <TQuery, TEntity>(IFilterExpression <TEntity, TId> expression)
where TQuery : class
where TEntity : IEntity <TId>
{
var filter = GetFilter <TQuery, TEntity>();
foreach (var entry in filter.Entries.Values)
{
expression.AddVariable(entry.Name, entry.Predicate);
}
}
public static LogicExpression Or(this IFilterExpression a, IFilterExpression b)
{
if (a is ILogicExpression)
{
(a as ILogicExpression).WithBracket = true;
}
if (b is ILogicExpression)
{
(b as ILogicExpression).WithBracket = true;
}
return(new LogicExpression(a, LogicOperator.Or, b));
}
private static Func <ILiquidValue, LiquidExpressionResult> InitialCast(
ITemplateContext ctx, IFilterExpression initialExpression)
{
return(expressionConstant =>
{
var result = expressionConstant != null
? CreateCastFilter(expressionConstant.GetType(), initialExpression.SourceType)
.Apply(ctx, expressionConstant)
: LiquidExpressionResult.Success(new None <ILiquidValue>());
return result;
});
}
private static string GetExpression(IFilterExpression filter)
{
string filterExpression = string.Empty;
string propertyFormatted = filter.PropertyName.Replace("Entity.", "").Replace(".", "/");
switch (filter.FilterExpression)
{
case FilterExpression.FilterType.GreaterThan:
filterExpression = string.Concat(propertyFormatted, " gt ", GetValueFormatted(filter.FilterValue));
break;
case FilterExpression.FilterType.GreaterThanOrEqualTo:
filterExpression = string.Concat(propertyFormatted, " ge ", GetValueFormatted(filter.FilterValue));
break;
case FilterExpression.FilterType.LessThan:
filterExpression = string.Concat(propertyFormatted, " lt ", GetValueFormatted(filter.FilterValue));
break;
case FilterExpression.FilterType.LessThanOrEqualTo:
filterExpression = string.Concat(propertyFormatted, " le ", GetValueFormatted(filter.FilterValue));
break;
case FilterExpression.FilterType.IsNull:
filterExpression = string.Concat(propertyFormatted, " eq null");
break;
case FilterExpression.FilterType.IsNotNull:
filterExpression = string.Concat(propertyFormatted, " not eq null");
break;
case FilterExpression.FilterType.Contains:
filterExpression = string.Concat("contains(tolower(", propertyFormatted, "), '", filter.FilterValue.ToString().ToLower(), "')");
break;
case FilterExpression.FilterType.IsEnum:
filterExpression = string.Concat(propertyFormatted, " eq ", filter.PropertyType.FullName, "'", filter.FilterValue, "'");
break;
default:
filterExpression = string.Concat(propertyFormatted, " eq ", GetValueFormatted(filter.FilterValue));
break;
}
return(filterExpression);
}
protected override string ExpressionFilterConverter(IFilterExpression <T> expression)
{
if (expression.PropertyType == typeof(byte[]))
{
return(TableQuery.GenerateFilterConditionForBinary(expression.PropertyName, GetInstruction(expression.Comparator), (byte[])expression.PropertyValue));
}
if (expression.PropertyType == typeof(bool) || expression.PropertyType == typeof(bool?))
{
return(TableQuery.GenerateFilterConditionForBool(expression.PropertyName, GetInstruction(expression.Comparator), (bool)expression.PropertyValue));
}
if (expression.PropertyType == typeof(DateTime) || expression.PropertyType == typeof(DateTime?))
{
return(TableQuery.GenerateFilterConditionForDate(expression.PropertyName, GetInstruction(expression.Comparator), (DateTime)expression.PropertyValue));
}
if (expression.PropertyType == typeof(DateTimeOffset) || expression.PropertyType == typeof(DateTimeOffset?))
{
return(TableQuery.GenerateFilterConditionForDate(expression.PropertyName, GetInstruction(expression.Comparator), (DateTimeOffset)expression.PropertyValue));
}
if (expression.PropertyType == typeof(double) || expression.PropertyType == typeof(double?))
{
return(TableQuery.GenerateFilterConditionForDouble(expression.PropertyName, GetInstruction(expression.Comparator), (double)expression.PropertyValue));
}
if (expression.PropertyType == typeof(Guid) || expression.PropertyType == typeof(Guid?))
{
return(TableQuery.GenerateFilterConditionForGuid(expression.PropertyName, GetInstruction(expression.Comparator), (Guid)expression.PropertyValue));
}
if (expression.PropertyType == typeof(int) || expression.PropertyType == typeof(int?))
{
return(TableQuery.GenerateFilterConditionForInt(expression.PropertyName, GetInstruction(expression.Comparator), (int)expression.PropertyValue));
}
if (expression.PropertyType == typeof(long) || expression.PropertyType == typeof(long?))
{
return(TableQuery.GenerateFilterConditionForLong(expression.PropertyName, GetInstruction(expression.Comparator), (long)expression.PropertyValue));
}
return(TableQuery.GenerateFilterCondition(expression.PropertyName, GetInstruction(expression.Comparator), expression.PropertyValue?.ToString() ?? string.Empty));
}
public static LogicExpression AnyEqVarParam(this IEnumerable <IColumnExpression> cols)
{
IFilterExpression filter = null;
LogicExpression logic = null;
foreach (var col in cols)
{
if (filter == null)
{
filter = col.EqVarParam();
}
else
{
logic = filter.Or(col.EqVarParam());
filter = logic;
}
//filter = filter == null ? col.EqVarParam() as IFilterExpression : filter.Or(col.EqVarParam());
}
return(logic);
}
public static LogicExpression AnyEq(this IEnumerable <IColumnExpression> cols, IEnumerable <IValueExpression> values)
{
IFilterExpression filter = null;
LogicExpression logic = null;
var em = values.GetEnumerator();
foreach (var col in cols)
{
em.MoveNext();
if (filter == null)
{
filter = col.Eq(em.Current);
}
else
{
logic = filter.Or(col.Eq(em.Current));
filter = logic;
}
//filter = filter == null ? col.Eq(em.Current) as IFilterExpression : filter.Or(col.Eq(em.Current));
}
return(logic);
}
protected virtual string Build(IFilterExpression <T> expression)
{
if (expression == null)
{
return(string.Empty);
}
StringBuilder queryBuilder = new StringBuilder();
if (expression.PropertyType != null)
{
var strExpression = ExpressionFilterConverter(expression);
queryBuilder.Append(strExpression);
}
if (expression.Group.Count > 0)
{
foreach (var operation in expression.Group)
{
if (!string.IsNullOrEmpty(InstructionsProvider.Get(operation.GroupOperator)))
{
queryBuilder.Append($" {InstructionsProvider.Get(operation.GroupOperator)} (");
}
queryBuilder.Append(Build(operation));
if (!string.IsNullOrEmpty(InstructionsProvider.Get(operation.GroupOperator)))
{
queryBuilder.Append(")");
}
}
}
if (!string.IsNullOrEmpty(expression.Operator))
{
queryBuilder.Append($" {InstructionsProvider.Get(expression.Operator)} ");
}
queryBuilder.Append(Build(expression.NextOperation));
return(queryBuilder.ToString().Trim());
}
public Task <TResult> GetByAsync <TResult>(ThaGet.Cqrs.Selector.Abstractions.ISelectExpression <TestEntity, TResult, int> selectExpression, IIncludeExpression <TestEntity, int> includeExpression, IFilterExpression <TestEntity, int> filterExpression) where TResult : class
{
throw new NotImplementedException();
}
public static ISelectStatement Where(this ISelectStatement select, IFilterExpression filter)
{
select.Where = new WhereClause(filter);
return(select);
}
/// <summary>
/// Add a new <see cref="IFilterExpression"></see> to the <see cref="IFilterGroup"></see>.
/// </summary>
/// <param name="filterGroup">
/// A <see cref="IFilterGroup"></see> to modify.
/// </param>
/// <param name="filter">
/// An <see cref="IFilterExpression"></see> to add.
/// </param>
/// <returns>
/// A reference to the <paramref name="filterGroup"/> after the
/// operation has completed.
/// </returns>
public static IFilterGroup AddExpression(this IFilterGroup filterGroup, IFilterExpression filter)
{
filterGroup.Filters.Add(filter);
return(filterGroup);
}
public NotFilterExpression(IFilterExpression negatedExpression)
{
NegatedExpression = negatedExpression ?? throw new ArgumentNullException(nameof(negatedExpression));
}
private static bool NeedsACast(Type expectedInputType, IFilterExpression filterExpression)
{
return(expectedInputType != null && !filterExpression.SourceType.IsAssignableFrom(expectedInputType));
}
protected virtual string ExpressionFilterConverter(IFilterExpression <T> expression)
{
return($"{expression.PropertyName} {InstructionsProvider.Get(expression.Comparator)} '{expression.PropertyValue}'");
}
public CompositeFilterExpression Add(IFilterExpression filterExpression)
{
return(this);
}
public static ISelectStatement FullJoin(this ISelectStatement select, ITableExpression table, IFilterExpression on)
{
IJoinExpression join = new JoinExpression(Operator.FullJoin, table, on);
return(Join(select, join));
}
protected BaseQueryExpressionBuilder(IFilterExpression <T> query, IQueryInstructionsProvider instructionsProvider)
{
Query = query;
InstructionsProvider = instructionsProvider;
}
public Task <TestEntity> GetByAsync(IFilterExpression <TestEntity, int> filterExpression)
{
throw new NotImplementedException();
}
public Task <ICollection <TestEntity> > FindAllByAsync(IIncludeExpression <TestEntity, int> includeExpression, IFilterExpression <TestEntity, int> filterExpression)
{
throw new NotImplementedException();
}
public static IUpdateStatement Where(this IUpdateStatement update, IFilterExpression filter)
{
update.Where = new WhereClause(filter);
return(update);
}
public Filter(string name, IFilterExpression rootExpression)
{
Name = name ?? throw new ArgumentNullException(nameof(name));
RootExpression = rootExpression ?? throw new ArgumentNullException(nameof(rootExpression));
m_Evaluator = new ExpressionEvaluationVisitor(this.RootExpression);
}
public ExpressionEvaluationVisitor(IFilterExpression rootExpression)
{
m_RootExpression = rootExpression ?? throw new ArgumentNullException(nameof(rootExpression));
}
public static Expression <Func <TEntity, bool> > GetFilter <TEntity>(this IFilterExpression <TEntity> filter)
{
return(filter.GetFilterExpressions().DefaultIfEmpty(GetDefaultExpression <TEntity>()).Combine(Expression.AndAlso));
}
public Task <ThaGet.Cqrs.Domain.Abstractions.IPagination <TResultType> > GetPaginationAsync <TResultType>(ThaGet.Cqrs.Selector.Abstractions.ISelectExpression <TestEntity, TResultType, int> selectExpression, IIncludeExpression <TestEntity, int> includeExpression, IFilterExpression <TestEntity, int> filterExpression, ISortExpression <TestEntity, int> sortExpression, int skip, int take) where TResultType : class
{
throw new NotImplementedException();
}
public static ISelectStatement Join(this ISelectStatement select, ITableExpression table, IFilterExpression on)
{
return(Join(select, table, on, Operator.InnerJoin));
}
public static ISelectStatement H(this ISelectStatement select, IFilterExpression filter)
{
return(Having(select, filter));
}
public IQueryable <TItem> FilterList <TItem>(IQueryable <TItem> source)
{
if (Filters?.Any() != true)
{
return(source);
}
var sourceExpression = _getFieldExpression.Parameters[0];
Expression lambda = null;
if (this.FilterType == TableFilterType.List)
{
lambda = Expression.Constant(false, typeof(bool));
}
IFilterExpression filterExpression = null;
if (FilterType == TableFilterType.FieldType)
{
filterExpression = _filterExpressionResolver.GetFilterExpression();
}
foreach (var filter in Filters)
{
if (this.FilterType == TableFilterType.List)
{
lambda = Expression.OrElse(lambda !, Expression.Invoke(OnFilter, Expression.Constant(filter.Value, typeof(TField)), _getFieldExpression.Body));
}
else // TableFilterType.FieldType
{
if (filter.Value == null && (filter.FilterCompareOperator != TableFilterCompareOperator.IsNull && filter.FilterCompareOperator != TableFilterCompareOperator.IsNotNull))
{
continue;
}
Expression constantExpression = null;
if (filter.FilterCompareOperator == TableFilterCompareOperator.IsNull || filter.FilterCompareOperator == TableFilterCompareOperator.IsNotNull)
{
constantExpression = Expression.Constant(null, typeof(TField));
}
else
{
constantExpression = Expression.Constant(filter.Value, typeof(TField));
}
var expression = filterExpression !.GetFilterExpression(filter.FilterCompareOperator, _getFieldExpression.Body, constantExpression);
if (lambda == null)
{
lambda = expression;
}
else
{
if (filter.FilterCondition == TableFilterCondition.And)
{
lambda = Expression.AndAlso(lambda, expression);
}
else
{
lambda = Expression.OrElse(lambda, expression);
}
}
}
}
if (lambda == null)
{
return(source);
}
else
{
return(source.Where(Expression.Lambda <Func <TItem, bool> >(lambda, sourceExpression)));
}
}
public Composition(IFilterExpression <I1, I2> item1, FilterCompositionOperator combiner, IFilterExpression <I1, I2> item2)
{
Item1 = item1;
Combiner = combiner;
Item2 = item2;
}
public void AddFilter <TQuery, TEntity>(IFilterExpression <TEntity, int> expression)
where TQuery : class
where TEntity : IEntity <int>
{
throw new NotImplementedException();
}
public static ISelectStatement Having(this ISelectStatement select, IFilterExpression filter)
{
select.Having = new HavingClause(filter);
return(select);
}
