private void VerifyFilterCount <TItem, TNullableItem>(IList <TItem> items, IFilterOperation filterOperation,
string operand, int expectedCount)
{
Assert.AreEqual(expectedCount, ApplyFilter(filterOperation, operand, items).Count);
var nullableItems = items.Cast <TNullableItem>().ToList();
CollectionAssert.AreEqual(ApplyFilter(filterOperation, operand, items),
ApplyFilter(filterOperation, operand, nullableItems));
Assert.IsNull(default(TNullableItem));
var nulls = Enumerable.Repeat(default(TNullableItem), 3).ToList();
Assert.AreEqual(expectedCount, ApplyFilter(filterOperation, operand, nullableItems).Count);
var itemsWithNulls = nullableItems.Concat(nulls);
int nullCount;
if (filterOperation == FilterOperations.OP_IS_BLANK ||
filterOperation == FilterOperations.OP_NOT_EQUALS ||
filterOperation == FilterOperations.OP_NOT_CONTAINS ||
filterOperation == FilterOperations.OP_NOT_STARTS_WITH)
{
nullCount = nulls.Count;
}
else
{
nullCount = 0;
}
Assert.AreEqual(nullCount, ApplyFilter(filterOperation, operand, nulls).Count);
Assert.AreEqual(nullCount + expectedCount, ApplyFilter(filterOperation, operand, itemsWithNulls).Count);
}
private bool IsValidForType <T>(IFilterOperation filterOperation)
{
var dataSchema = new DataSchema();
ColumnDescriptor columnDescriptor = ColumnDescriptor.RootColumn(dataSchema, typeof(T));
return(filterOperation.IsValidFor(columnDescriptor));
}
/// <inheritdoc />
public InOperation(
[NotNull] Expression expression,
[NotNull] ISqlDialect dialect,
[NotNull] FilterParseHelpers parseHelper,
bool skipBrackets
) : base(expression, dialect, skipBrackets)
{
var right = (CallExpression.Method.IsStatic
? CallExpression.Arguments[0]
: CallExpression.Object) ?? throw new ArgumentException("Null object for Contains method");
var enumerable = Expression.Lambda(right).Compile().DynamicInvoke() as IEnumerable;
var values = (enumerable ?? throw new InvalidOperationException("Expression was not evaluated to IEnumerable!"))
.Cast <object>()
.Select(val => new SimpleValueOperation(val, dialect, parseHelper))
.ToList();
if (values.Count > 0)
{
_left = (CallExpression.Method.IsStatic
? parseHelper.ParseExpression(CallExpression.Arguments[1])
: parseHelper.ParseExpression(CallExpression.Arguments[0])) ?? throw new ArgumentException("Null parameter for Contains method");
_values = values;
}
else
{
_emptyEnumOperation = new SimpleBoolOperation(new SimpleValueOperation(true, Dialect, parseHelper), dialect);
}
}
private RowFilter.ColumnFilter CreateColumnFilter(ColumnId columnId, IFilterOperation filterOp, double operand)
{
var op = FilterPredicate.CreateFilterPredicate(_bindingListSource.ViewInfo.DataSchema,
typeof(double), filterOp,
operand.ToString(CultureInfo.CurrentCulture));
return(new RowFilter.ColumnFilter(columnId, op));
}
public LikeOperation(
[NotNull] Expression expression,
[NotNull] ISqlDialect dialect,
[NotNull] FilterParseHelpers parseHelper,
bool skipBrackets) : base(expression, dialect, skipBrackets)
{
_left = parseHelper.ParseExpression(CallExpression.Arguments[0]);
_right = parseHelper.ParseExpression(CallExpression.Arguments[1]);
}
private IFilterOperation ParseOperation(string stringOperation)
{
IFilterOperation operation = _filterOperationFactory.GetByShorthandName(stringOperation);
if (operation == null)
{
throw new NotSupportedException($"Filter operation {stringOperation} is not supported!");
}
return(operation);
}
private FilterPredicate SafeCreateFilterPredicate(DataSchema dataSchema, Type columnType,
IFilterOperation filterOperation, string operand)
{
try
{
return(FilterPredicate.CreateFilterPredicate(dataSchema, columnType, filterOperation, operand));
}
catch
{
return(FilterPredicate.CreateFilterPredicate(dataSchema, typeof(string), filterOperation, operand));
}
}
public UnaryToBinaryOperation(
[NotNull] Expression expression,
[NotNull] IFilterOperation left,
[NotNull] IFilterOperation right,
ISqlDialect dialect,
bool skipBrackets) : base(dialect)
{
_expression = expression ?? throw new ArgumentNullException(nameof(expression));
_left = left ?? throw new ArgumentNullException(nameof(left));
_right = right ?? throw new ArgumentNullException(nameof(right));
_skipBrackets = skipBrackets;
}
private Filter[] ParseFilterItem(KeyValuePair <string, string[]> input)
{
string[] values = input.Key.Split(FilterItemSplitters).Where(item => !string.IsNullOrEmpty(item)).ToArray();
string fieldName = string.Join('.', values.Skip(1).Take(values.Length - 2));
IFilterOperation filterOperation = ParseOperation(values.Last());
return(input.Value.Select(param => new Filter
{
Operation = filterOperation,
PropertyName = fieldName,
Value = param
}).ToArray());
}
public bool SetFilterOperation(int index, IFilterOperation filterOperation)
{
var comboBox = new[] { comboOperation1, comboOperation2 }[index];
for (int i = 0; i < comboBox.Items.Count; i++)
{
if (Equals(filterOperation, ((FilterItem)comboBox.Items[i]).FilterOperation))
{
comboBox.SelectedIndex = i;
return(true);
}
}
return(false);
}
private List <TItem> ApplyFilter <TItem>(IFilterOperation filterOperation, string operand, IEnumerable <TItem> items)
{
var dataSchema = new DataSchema(new DataSchemaLocalizer(CultureInfo.CurrentCulture));
var columnDescriptor = ColumnDescriptor.RootColumn(dataSchema, typeof(TItem));
if (null != operand)
{
Assert.IsNotNull(filterOperation.GetOperandType(columnDescriptor));
}
var filterPredicate = FilterPredicate.CreateFilterPredicate(dataSchema, typeof(TItem), filterOperation, operand);
var predicate = filterPredicate.MakePredicate(dataSchema, typeof(TItem));
return(items.Where(item => predicate(item)).ToList());
}
/// <inheritdoc />
public override void AppendSql(StringBuilder builder, GeneratorContext filterParams)
{
if (!SkipBrackets)
{
builder.Append(Dialect.OpenBracket);
}
if (_emptyEnumOperation != null)
{
_emptyEnumOperation.AppendSql(builder, filterParams);
}
else
{
// ReSharper disable once PossibleNullReferenceException
_left.AppendSql(builder, filterParams);
builder.Append(" " + Dialect.InKeyword + " ");
builder.Append(Dialect.OpenBracket);
// ReSharper disable once PossibleNullReferenceException
using var enumerator = _values.GetEnumerator();
IFilterOperation first = null;
while (enumerator.MoveNext())
{
var current = enumerator.Current;
if (first != null && current != null)
{
builder.Append(", ");
}
else
{
first = enumerator.Current;
}
current?.AppendSql(builder, filterParams);
}
builder.Append(Dialect.CloseBracket);
}
if (!SkipBrackets)
{
builder.Append(Dialect.CloseBracket);
}
}
private List <TItem> ApplyFilter <TItem>(IFilterOperation filterOperation, string operand, IEnumerable <TItem> items)
{
var dataSchema = new DataSchema();
var columnDescriptor = ColumnDescriptor.RootColumn(dataSchema, typeof(TItem));
if (null == operand)
{
Assert.IsNull(filterOperation.GetOperandType(columnDescriptor));
}
else
{
Assert.IsNotNull(filterOperation.GetOperandType(columnDescriptor));
}
var predicate = filterOperation.MakePredicate(columnDescriptor, operand);
return(items.Where(item => predicate(item)).ToList());
}
public bool SetFilterOperation(int iRow, IFilterOperation filterOperation)
{
dataGridViewFilter.CurrentCell = dataGridViewFilter.Rows[iRow].Cells[colFilterOperation.Index];
var dataGridViewComboBoxEditingControl = (DataGridViewComboBoxEditingControl) dataGridViewFilter.EditingControl;
bool found = false;
for (int i = 0; i < dataGridViewComboBoxEditingControl.Items.Count; i++)
{
if (Equals(dataGridViewComboBoxEditingControl.Items[i], filterOperation.DisplayName))
{
dataGridViewComboBoxEditingControl.SelectedIndex = i;
found = true;
break;
}
}
dataGridViewFilter.EndEdit();
return found;
}
public bool SetFilterOperation(int iRow, IFilterOperation filterOperation)
{
dataGridViewFilter.CurrentCell = dataGridViewFilter.Rows[iRow].Cells[colFilterOperation.Index];
var dataGridViewComboBoxEditingControl = (DataGridViewComboBoxEditingControl)dataGridViewFilter.EditingControl;
bool found = false;
for (int i = 0; i < dataGridViewComboBoxEditingControl.Items.Count; i++)
{
if (Equals(dataGridViewComboBoxEditingControl.Items[i], filterOperation.DisplayName))
{
dataGridViewComboBoxEditingControl.SelectedIndex = i;
found = true;
break;
}
}
dataGridViewFilter.EndEdit();
return(found);
}
private static object GetFilterValue <T>(this IFilterOperation operation)
{
var properties = TypeDescriptor.GetProperties(typeof(T));
var property = properties.Find(operation.Property, true);
var converter = TypeDescriptor.GetConverter(property.PropertyType);
object value = null;
var filterValueType = operation.Value.GetType();
if (property.PropertyType != filterValueType)
{
if (filterValueType == typeof(Newtonsoft.Json.Linq.JArray))
{
if (property.PropertyType == typeof(DateTime))
{
value = JsonConvert.DeserializeObject <List <DateTime> >(operation.Value.ToString(),
new IsoDateTimeConverter()
{
DateTimeFormat = "yyyy-dd-MM"
});
}
else if (property.PropertyType == typeof(Int32))
{
value = JsonConvert.DeserializeObject <List <Int32> >(operation.Value.ToString());
}
else if (property.PropertyType == typeof(Decimal))
{
value = JsonConvert.DeserializeObject <List <Decimal> >(operation.Value.ToString());
}
else if (operation.Operator.Equals("in", StringComparison.InvariantCultureIgnoreCase))
{
value = JsonConvert.DeserializeObject <List <String> >(operation.Value.ToString());
}
}
else
{
value = converter.ConvertFromString(null, CultureInfo.InvariantCulture, operation.Value.ToString());
}
}
return(value = value ?? operation.Value);
}
private void AddFilter(DataboundGridForm databoundGridForm, PropertyPath propertyPath,
IFilterOperation filterOperation, string filterOperand)
{
var viewEditor = ShowDialog<ViewEditor>(databoundGridForm.NavBar.CustomizeView);
RunUI(() =>
{
viewEditor.ViewName = "Custom View";
viewEditor.TabControl.SelectTab(1);
Assert.IsTrue(viewEditor.FilterTab.TrySelectColumn(propertyPath));
int iFilter = viewEditor.ViewInfo.Filters.Count;
viewEditor.FilterTab.AddSelectedColumn();
viewEditor.FilterTab.SetFilterOperation(iFilter, filterOperation);
if (null != filterOperand)
{
viewEditor.FilterTab.SetFilterOperand(iFilter, filterOperand);
}
});
OkDialog(viewEditor, viewEditor.OkDialog);
WaitForConditionUI(() => databoundGridForm.IsComplete);
}
private static Operator AsOperatorEnum(this IFilterOperation operation)
{
switch (operation.Operator)
{
case "eq":
case "==":
return(Operator.Equal);
case "ne":
case "!=":
return(Operator.NotEqual);
case "gt":
case ">":
return(Operator.GreaterThan);
case "ge":
case ">=":
return(Operator.GreaterOrEqual);
case "lt":
case "<":
return(Operator.LessThen);
case "le":
case "<=":
return(Operator.LessOrEqual);
case "in":
return(Operator.In);
case "notin":
return(Operator.NotIn);
case "like":
return(Operator.Like);
default:
return(Operator.None);
}
}
private void AddFilter(DataboundGridForm databoundGridForm, PropertyPath propertyPath,
IFilterOperation filterOperation, string filterOperand)
{
var viewEditor = ShowDialog <ViewEditor>(databoundGridForm.NavBar.CustomizeView);
RunUI(() =>
{
viewEditor.ViewName = "Custom View";
viewEditor.TabControl.SelectTab(1);
Assert.IsTrue(viewEditor.FilterTab.TrySelectColumn(propertyPath));
int iFilter = viewEditor.ViewInfo.Filters.Count;
viewEditor.FilterTab.AddSelectedColumn();
viewEditor.FilterTab.SetFilterOperation(iFilter, filterOperation);
if (null != filterOperand)
{
viewEditor.FilterTab.SetFilterOperand(iFilter, filterOperand);
}
});
OkDialog(viewEditor, viewEditor.OkDialog);
WaitForConditionUI(() => databoundGridForm.IsComplete);
}
public NotOperation(
[NotNull] UnaryExpression expression,
[NotNull] ISqlDialect dialect,
[NotNull] FilterParseHelpers parseHelper
) : base(dialect)
{
if (expression == null)
{
throw new ArgumentNullException(nameof(expression));
}
_expression = parseHelper.ParseExpression(expression.Operand.UnwrapConvert(), true);
if (!(_expression is BinaryOperation || _expression is NotOperation || _expression is PseudoMethodCallOperation))
{
_expression = new UnaryToBinaryOperation(
expression.Operand,
_expression,
new SimpleValueOperation(expression.Operand.Type == typeof(bool) ? (object)true : 1, Dialect, parseHelper),
Dialect,
true
);
}
}
private static Expression AsExpression <T>(this IFilterOperation operation,
MemberExpression member, ConstantExpression constant)
{
switch (operation.AsOperatorEnum())
{
case Operator.GreaterThan:
return(Expression.GreaterThan(member, constant));
case Operator.GreaterOrEqual:
return(Expression.GreaterThanOrEqual(member, constant));
case Operator.LessThen:
return(Expression.LessThan(member, constant));
case Operator.LessOrEqual:
return(Expression.LessThanOrEqual(member, constant));
case Operator.Equal:
return(Expression.Equal(member, constant));
case Operator.NotEqual:
return(Expression.NotEqual(member, constant));
case Operator.In:
case Operator.Like:
return(Contains(member, constant));
case Operator.NotIn:
return(NotContains(member, constant));
case Operator.None:
break;
}
throw new Exception($"Invalid operator {operation.AsOperatorEnum()} provided!");
}
public FilterItem(string displayName, IFilterOperation filterOperation)
{
DisplayName = displayName;
FilterOperation = filterOperation;
}
/// <inheritdoc />
public SimpleBoolOperation([NotNull] IFilterOperation operation, [NotNull] ISqlDialect dialect) : base(dialect)
{
_operation = operation ?? throw new ArgumentNullException(nameof(operation));
}
public ColumnFilter(String columnCaption, IFilterOperation filterOperation, String operand)
{
ColumnCaption = columnCaption;
FilterOperation = filterOperation;
Operand = operand;
}
public FilterSpec SetOperation(IFilterOperation operation)
{
return(SetOp(operation == null ? string.Empty : operation.OpName));
}
private void VerifyFilterCountStructs <TItem>(IList <TItem> items, IFilterOperation filterOperation, string operand,
int expectedCount) where TItem : struct
{
VerifyFilterCount <TItem, TItem?>(items, filterOperation, operand, expectedCount);
}
public NotOperation([NotNull] IFilterOperation filterExpression, ISqlDialect dialect) : base(dialect)
{
_expression = filterExpression ?? throw new ArgumentNullException(nameof(filterExpression));
}
/// <summary>
/// Constructs a new FilterPredicate from a value that the user has typed in the user interface.
/// "operandText" is expected to be formatted according to the locale settings of "dataSchema".
/// </summary>
public static FilterPredicate CreateFilterPredicate(DataSchema dataSchema, Type columnType, IFilterOperation filterOperation, string operandText)
{
object operandValue;
if (string.IsNullOrEmpty(operandText))
{
operandValue = null;
}
else
{
Type operandType = filterOperation.GetOperandType(dataSchema, columnType);
if (null == operandType)
{
operandValue = null;
}
else
{
operandValue = ParseOperandValue(dataSchema.DataSchemaLocalizer.FormatProvider, operandType, operandText);
}
}
string invariantOperandText = OperandValueToString(CultureInfo.InvariantCulture, operandValue);
return(new FilterPredicate(filterOperation, invariantOperandText));
}
public FilterItem(string displayName, IFilterOperation filterOperation)
{
DisplayName = displayName;
FilterOperation = filterOperation;
}
RowFilter.ColumnFilter CheckFilters(IEnumerable <RowFilter.ColumnFilter> filters, ColumnId columnId, IFilterOperation filterOp, double operand, out bool needsUpdate)
{
var filter = filters.FirstOrDefault(f => Equals(f.ColumnId, columnId) &&
ReferenceEquals(f.Predicate.FilterOperation, filterOp));
if (filter == null)
{
needsUpdate = false;
return(null);
}
needsUpdate =
filter.Predicate.GetOperandDisplayText(_bindingListSource.ViewInfo.DataSchema, typeof(double)) !=
operand.ToString(CultureInfo.CurrentCulture);
return(filter);
}
public ColumnFilter(String columnCaption, IFilterOperation filterOperation, String operand)
{
ColumnCaption = columnCaption;
FilterOperation = filterOperation;
Operand = operand;
}
public bool SetFilterOperation(int index, IFilterOperation filterOperation)
{
var comboBox = new[] {comboOperation1, comboOperation2}[index];
for (int i = 0; i < comboBox.Items.Count; i++)
{
if (Equals(filterOperation, ((FilterItem) comboBox.Items[i]).FilterOperation))
{
comboBox.SelectedIndex = i;
return true;
}
}
return false;
}
public void ApplyFilter(IFilterOperation filterOperation)
{
_segments.ForEach(segment => segment.ApplyFilter(filterOperation));
}
private FilterPredicate(IFilterOperation filterOperation, String invariantOperandText)
{
FilterOperation = filterOperation;
InvariantOperandText = invariantOperandText;
}
public FilterNode(IFilterOperation operation, string filterString)
{
filterOperation = operation;
identifier = filterString;
}
