private static void GetNodeFromComparisonFilter(ComparisonFilter comparisonFilter, Hashtable allowedProperties, List <FilterNode> filterNodes, bool isNotFilter)
{
if (allowedProperties.ContainsKey(comparisonFilter.Property.Name))
{
FilterNode filterNode = new FilterNode();
filterNode.FilterablePropertyDescription = (FilterablePropertyDescription)allowedProperties[comparisonFilter.Property.Name];
filterNode.Operator = (PropertyFilterOperator)comparisonFilter.ComparisonOperator;
if (typeof(Enum).IsAssignableFrom(comparisonFilter.Property.Type))
{
filterNode.Value = Enum.Parse(comparisonFilter.Property.Type, comparisonFilter.PropertyValue.ToString(), true);
}
else if (typeof(bool).IsAssignableFrom(comparisonFilter.Property.Type))
{
filterNode.Value = !isNotFilter;
}
else if (comparisonFilter.Property.Type == typeof(MultiValuedProperty <string>))
{
filterNode.Value = comparisonFilter.PropertyValue.ToUserFriendText(CultureInfo.CurrentUICulture.TextInfo.ListSeparator, (object input) => false);
}
else
{
filterNode.Value = MonadFilter.ConvertValueFromString(comparisonFilter.PropertyValue, comparisonFilter.Property.Type);
}
filterNodes.Add(filterNode);
return;
}
throw new InvalidOperationException(Strings.UnknownFilterableProperty(comparisonFilter.Property.Name).ToString());
}
public override void Synchronize(FilterNode sourceNode, FilterNode targetNode)
{
if (sourceNode != targetNode)
{
targetNode.FilterablePropertyDescription = sourceNode.FilterablePropertyDescription;
targetNode.Operator = sourceNode.Operator;
targetNode.Value = sourceNode.Value;
}
}
private static void GetNodesFromExpressionTree(QueryFilter queryFilter, Hashtable allowedProperties, List <FilterNode> filterNodes)
{
if (queryFilter != null)
{
CompositeFilter compositeFilter = queryFilter as CompositeFilter;
TextFilter textFilter = queryFilter as TextFilter;
ComparisonFilter comparisonFilter = queryFilter as ComparisonFilter;
ExistsFilter existsFilter = queryFilter as ExistsFilter;
NotFilter notFilter = queryFilter as NotFilter;
if (compositeFilter != null)
{
using (ReadOnlyCollection <QueryFilter> .Enumerator enumerator = compositeFilter.Filters.GetEnumerator())
{
while (enumerator.MoveNext())
{
QueryFilter queryFilter2 = enumerator.Current;
FilterNode.GetNodesFromExpressionTree(queryFilter2, allowedProperties, filterNodes);
}
return;
}
}
if (notFilter != null)
{
textFilter = (notFilter.Filter as TextFilter);
existsFilter = (notFilter.Filter as ExistsFilter);
comparisonFilter = (notFilter.Filter as ComparisonFilter);
if ((textFilter == null && existsFilter == null && comparisonFilter == null) || (comparisonFilter != null && !typeof(bool).IsAssignableFrom(comparisonFilter.Property.Type)))
{
throw new InvalidOperationException(Strings.InvalidNotFilter.ToString());
}
}
if (textFilter != null)
{
FilterNode.GetNodeFromTextFilter(textFilter, allowedProperties, filterNodes, notFilter != null);
return;
}
if (comparisonFilter != null)
{
FilterNode.GetNodeFromComparisonFilter(comparisonFilter, allowedProperties, filterNodes, notFilter != null);
return;
}
if (existsFilter != null)
{
FilterNode.GetNodeFromExistsFilter(existsFilter, allowedProperties, filterNodes, null != notFilter);
return;
}
throw new InvalidOperationException(Strings.UnsuportedFilterType(queryFilter.GetType()).ToString());
}
}
public static List <FilterNode> GetNodesFromSerializedQueryFilter(byte[] serializedQueryFilter, IList <FilterablePropertyDescription> filterableProperties, ObjectSchema schema)
{
List <FilterNode> list = new List <FilterNode>();
if (serializedQueryFilter != null)
{
Hashtable hashtable = new Hashtable(filterableProperties.Count);
foreach (FilterablePropertyDescription filterablePropertyDescription in filterableProperties)
{
hashtable.Add(filterablePropertyDescription.PropertyDefinition.Name, filterablePropertyDescription);
}
FilterNode.GetNodesFromExpressionTree((QueryFilter)WinformsHelper.DeSerialize(serializedQueryFilter), hashtable, list);
}
return(list);
}
private static void GetNodeFromExistsFilter(ExistsFilter existsFilter, Hashtable allowedProperties, List <FilterNode> filterNodes, bool isNotFilter)
{
if (allowedProperties.ContainsKey(existsFilter.Property.Name))
{
FilterNode filterNode = new FilterNode();
filterNode.FilterablePropertyDescription = (FilterablePropertyDescription)allowedProperties[existsFilter.Property.Name];
if (isNotFilter)
{
filterNode.Operator = PropertyFilterOperator.NotPresent;
}
else
{
filterNode.Operator = PropertyFilterOperator.Present;
}
filterNodes.Add(filterNode);
return;
}
throw new InvalidOperationException(Strings.UnknownFilterableProperty(existsFilter.Property.Name).ToString());
}
internal FilterValuePropertyDescriptor(FilterNode owner, PropertyDescriptor pd) : base(pd)
{
this.owner = owner;
this.original = pd;
}
private static void GetNodeFromTextFilter(TextFilter textFilter, Hashtable allowedProperties, List <FilterNode> filterNodes, bool isNotFilter)
{
if (allowedProperties.ContainsKey(textFilter.Property.Name))
{
FilterNode filterNode = new FilterNode();
filterNode.FilterablePropertyDescription = (FilterablePropertyDescription)allowedProperties[textFilter.Property.Name];
switch (textFilter.MatchOptions)
{
case MatchOptions.SubString:
if (isNotFilter)
{
filterNode.Operator = PropertyFilterOperator.NotContains;
}
else
{
filterNode.Operator = PropertyFilterOperator.Contains;
}
break;
case MatchOptions.Prefix:
filterNode.Operator = PropertyFilterOperator.StartsWith;
break;
case MatchOptions.Suffix:
filterNode.Operator = PropertyFilterOperator.EndsWith;
break;
default:
throw new InvalidOperationException(Strings.UnsupportedTextFilter(textFilter.Property.Name, textFilter.MatchOptions.ToString(), textFilter.Text).ToString());
}
if (typeof(Enum).IsAssignableFrom(filterNode.PropertyDefinition.Type) && filterNode.PropertyDefinition.Type.GetCustomAttributes(typeof(FlagsAttribute), false).Length != 0)
{
if (isNotFilter)
{
filterNode.Operator = PropertyFilterOperator.NotEqual;
}
else
{
filterNode.Operator = PropertyFilterOperator.Equal;
}
filterNode.Value = Enum.Parse(filterNode.PropertyDefinition.Type, textFilter.Text, true);
}
else
{
filterNode.Value = textFilter.Text;
}
if (isNotFilter)
{
if (!typeof(Enum).IsAssignableFrom(filterNode.PropertyDefinition.Type) && filterNode.Operator != PropertyFilterOperator.NotContains)
{
throw new InvalidOperationException(Strings.InvalidTextFilterForNonEnums(filterNode.Operator.ToString()).ToString());
}
if (typeof(Enum).IsAssignableFrom(filterNode.PropertyDefinition.Type) && filterNode.Operator != PropertyFilterOperator.NotEqual)
{
throw new InvalidOperationException(Strings.InvalidTextFilterForEnums(filterNode.Operator.ToString()).ToString());
}
}
filterNodes.Add(filterNode);
return;
}
throw new InvalidOperationException(Strings.UnknownFilterableProperty(textFilter.Property.Name).ToString());
}
internal static List <FilterNode> GetNodesFromExpressionString(string expression, IList <FilterablePropertyDescription> filterableProperties, ObjectSchema schema)
{
return(FilterNode.GetNodesFromSerializedQueryFilter(FilterNode.ConvertExpressionStringToByteArray(expression, schema), filterableProperties, schema));
}
public abstract void Synchronize(FilterNode sourceNode, FilterNode targetNode);
