public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { var count = context.Path.Count(); if (value != null && (count == 0 || (count == 2 && context.Path.Last() == InvariantPartitioning.Key))) { FilterNode filter = null; if (value is string s) { filter = new FilterComparison(Path(context), FilterOperator.Equals, new FilterValue(s)); } else if (value is double d) { filter = new FilterComparison(Path(context), FilterOperator.Equals, new FilterValue(d)); } if (filter != null) { var found = await context.GetContentIdsAsync(context.SchemaId, filter); if (found.Any(x => x != context.ContentId)) { addError(context.Path, "Another content with the same value exists."); } } } }
internal EntityColumnFilter(EntityColumn column, string groupName, FilterCondition condition, FilterComparison comparison) { this.Column = column; this.Comparison = comparison; this.Condition = condition; this.GroupName = groupName; }
/// <summary> /// Constructs a new class filter term. /// </summary> /// <param name="aspect">The class aspect to filter.</param> /// <param name="ordinal">The ordinal position of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> public ClassFilterTerm(Aspect aspect, int ordinal, FilterComparison comparison, object value) { this._Aspect = aspect; this._Ordinal = ordinal; this._Comparison = comparison; this._Value = value; }
protected internal void Filter( IEnumerable<EntityColumn> columns, string @group = "Default", FilterCondition condition = FilterCondition.Default, FilterComparison comparison = FilterComparison.Default) { this.Filterables.AddRange(columns.Select(c => new EntityColumnFilter(c, @group, condition, comparison))); }
protected internal void Filter( EntityColumn column, string @group = "Default", FilterCondition condition = FilterCondition.Default, FilterComparison comparison = FilterComparison.Default) { this.Filterables.Add(new EntityColumnFilter(column, @group, condition, comparison)); }
public InListComparation(PropertyReference <T, TValue> property, IEnumerable <TValue> values) { Property = property; Values = values.ToList(); operands.Add(property); operands.AddRange(Values.Select(val => new ScalarValue <TValue>(val))); NodeType = FilterNodeType.ValueInList; Operation = FilterComparison.ValueInList; }
public DynamicComparation(string property, object value, FilterComparison op = FilterComparison.Equal) { PropertyName = property; Value = value; Operation = op; NodeType = FilterNodeType.Compare; operands.Add(new RawPropertyReference(PropertyName)); operands.Add(new DynamicScalar(value)); }
public CompareOperation(ComparationOperand <TValue> left, ComparationOperand <TValue> right, FilterComparison op = FilterComparison.Equal) { Left = left; Right = right; Operation = op; NodeType = FilterNodeType.Compare; operands.Add(left); operands.Add(right); }
public void Using_Empty_FilterComparison_Works() { using (_Connection) { var filter = new FilterComparison(); var people = _Connection.Select <Person>(@"SELECT * FROM people") .Where(filter); Assert.AreEqual(9, people.Count()); } }
public override FilterNode Visit(FilterComparison nodeIn) { var value = nodeIn.Rhs.Value; if (value is Instant && !string.Equals(nodeIn.Lhs[0], "mt", StringComparison.OrdinalIgnoreCase) && !string.Equals(nodeIn.Lhs[0], "ct", StringComparison.OrdinalIgnoreCase)) { return(new FilterComparison(pathConverter(nodeIn.Lhs), nodeIn.Operator, new FilterValue(value.ToString()))); } return(new FilterComparison(pathConverter(nodeIn.Lhs), nodeIn.Operator, nodeIn.Rhs)); }
public override FilterNode Visit(FilterComparison nodeIn) { if (nodeIn.Rhs.Value is string stringValue && IsDataPath(nodeIn.Lhs) && IsTagField(nodeIn.Lhs)) { var tagNames = Task.Run(() => tagService.GetTagIdsAsync(appId, TagGroups.Schemas(schema.Id), HashSet.Of(stringValue))).Result; if (tagNames.TryGetValue(stringValue, out var normalized)) { return(new FilterComparison(nodeIn.Lhs, nodeIn.Operator, new FilterValue(normalized))); } } return(nodeIn); }
public override FilterNode Visit(FilterComparison nodeIn) { if (string.Equals(nodeIn.Lhs[0], nameof(IAssetEntity.Tags), StringComparison.OrdinalIgnoreCase) && nodeIn.Rhs.Value is string stringValue) { var tagNames = Task.Run(() => tagService.GetTagIdsAsync(appId, TagGroups.Assets, HashSet.Of(stringValue))).Result; if (tagNames.TryGetValue(stringValue, out var normalized)) { return(new FilterComparison(nodeIn.Lhs, nodeIn.Operator, new FilterValue(normalized))); } } return(nodeIn); }
public FilterComparison InterpretConditionItem(SyneryParser.FilterCommandConditionItemContext context) { FilterComparison filter = new FilterComparison(); filter.FieldName = context.filterCommandListItemField().GetText(); filter.Value = Controller.Interpret <SyneryParser.SingleValueContext, IValue>(context.filterCommandListItemExpression().singleValue()); // equality expressions if (context.EQUAL() != null) { filter.Operator = FilterComparisonOperatorEnum.Equal; } if (context.NOTEQUAL() != null) { filter.Operator = FilterComparisonOperatorEnum.NotEqual; } if (context.EXACTLYEQUAL() != null) { filter.Operator = FilterComparisonOperatorEnum.ExactlyEqual; } if (context.EXACTLYNOTEQUAL() != null) { filter.Operator = FilterComparisonOperatorEnum.ExactlyNotEqual; } // comparison expressions if (context.GT() != null) { filter.Operator = FilterComparisonOperatorEnum.GreaterThan; } if (context.LT() != null) { filter.Operator = FilterComparisonOperatorEnum.LessThan; } if (context.GE() != null) { filter.Operator = FilterComparisonOperatorEnum.GreaterThanOrEqual; } if (context.LE() != null) { filter.Operator = FilterComparisonOperatorEnum.LessThanOrEqual; } return(filter); }
public async Task ValidateAsync(object value, ValidationContext context, AddError addError) { if (value is ICollection <Guid> contentIds) { var filter = new FilterComparison(Path, FilterOperator.In, new FilterValue(contentIds.ToList())); var foundIds = await context.GetContentIdsAsync(schemaId, filter); foreach (var id in contentIds) { if (!foundIds.Contains(id)) { addError(context.Path, $"Contains invalid reference '{id}'."); } } } }
public override FilterDefinition <T> Visit(FilterComparison nodeIn) { var propertyName = string.Join(".", nodeIn.Lhs); switch (nodeIn.Operator) { case FilterOperator.Empty: return(Filter.Or(Filter.Exists(propertyName, false), Filter.Eq(propertyName, default(T)), Filter.Eq(propertyName, string.Empty), Filter.Eq(propertyName, new T[0]))); case FilterOperator.StartsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s))); case FilterOperator.Contains: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s))); case FilterOperator.EndsWith: return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$"))); case FilterOperator.Equals: return(Filter.Eq(propertyName, nodeIn.Rhs.Value)); case FilterOperator.GreaterThan: return(Filter.Gt(propertyName, nodeIn.Rhs.Value)); case FilterOperator.GreaterThanOrEqual: return(Filter.Gte(propertyName, nodeIn.Rhs.Value)); case FilterOperator.LessThan: return(Filter.Lt(propertyName, nodeIn.Rhs.Value)); case FilterOperator.LessThanOrEqual: return(Filter.Lte(propertyName, nodeIn.Rhs.Value)); case FilterOperator.NotEquals: return(Filter.Ne(propertyName, nodeIn.Rhs.Value)); case FilterOperator.In: return(Filter.In(propertyName, ((IList)nodeIn.Rhs.Value).OfType <object>())); } throw new NotSupportedException(); }
public override FilterNode Visit(FilterComparison nodeIn) { FilterComparison result; var value = nodeIn.Rhs.Value; if (value is Instant && !string.Equals(nodeIn.Lhs[0], "mt", StringComparison.OrdinalIgnoreCase) && !string.Equals(nodeIn.Lhs[0], "ct", StringComparison.OrdinalIgnoreCase)) { result = new FilterComparison(pathConverter(nodeIn.Lhs), nodeIn.Operator, new FilterValue(value.ToString())); } else { result = new FilterComparison(pathConverter(nodeIn.Lhs), nodeIn.Operator, nodeIn.Rhs); } if (result.Lhs.Count == 1 && result.Lhs[0] == "_id" && result.Rhs.Value is List <Guid> guidList) { result = new FilterComparison(nodeIn.Lhs, nodeIn.Operator, new FilterValue(guidList.Select(x => x.ToString()).ToList())); } return(result); }
private static BsonRegularExpression BuildRegex(FilterComparison node, Func <string, string> formatter) { return(new BsonRegularExpression(formatter(node.Rhs.Value.ToString()), "i")); }
/// <summary> /// Creates a filter node wrapping a filter term. /// </summary> /// <param name="aspect">The class aspect to filter.</param> /// <param name="name">The name of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> public ClassFilterNode(Aspect aspect, string name, FilterComparison comparison, object value) : this(aspect, aspect.GetOrdinalOrException(name), comparison, value) { }
/// <summary> /// Creates a filter node wrapping a filter term. /// </summary> /// <param name="aspect">The class aspect to filter.</param> /// <param name="ordinal">The ordinal position of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> public ClassFilterNode(Aspect aspect, int ordinal, FilterComparison comparison, object value) : this(new ClassFilterTerm(aspect, ordinal, comparison, value)) { }
/// <summary> /// Creates a filter expression with a single filter term. /// </summary> /// <param name="aspect">The class aspect to filter.</param> /// <param name="name">The name of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> public ClassFilterExpression(Aspect aspect, string name, FilterComparison comparison, object value) : this(new ClassFilterTerm(aspect, name, comparison, value)) { }
/// <summary> /// Appends a filter term with an OR operation. /// </summary> /// <param name="name">The name of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> /// <returns>The ClassFilterExpression.</returns> public ClassFilterExpression Or(string name, FilterComparison comparison, object value) { return(Or(new ClassFilterTerm(_Aspect, name, comparison, value))); }
/// <summary> /// Appens a filter term with an AND operation. /// </summary> /// <param name="ordinal">The ordinal position of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> /// <returns>The T.</returns> public ClassDelete And(int ordinal, FilterComparison comparison, object value) { return(And(new ClassFilterTerm(_Aspect, ordinal, comparison, value))); }
/// <summary> /// Sets a filter term as the only filter node. /// </summary> /// <param name="name">The name of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> /// <returns>The T.</returns> public ClassSelect <T> Where(string name, FilterComparison comparison, object value) { return(Where(new ClassFilterTerm(_Aspect, name, comparison, value))); }
/// <summary> /// Set a filter term as the only filter node. /// </summary> /// <param name="ordinal">The ordinal position of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> /// <returns>The ClassSelect of TEntity</returns> public ClassSelect <T> Where(int ordinal, FilterComparison comparison, object value) { return(Where(new ClassFilterTerm(_Aspect, ordinal, comparison, value))); }
public DataFilter <T> Compare <TProperty>(string name, TProperty value, FilterComparison op = FilterComparison.Equal) where TProperty : IComparable <TProperty>, IEquatable <TProperty> { return(new DataFilter <T>(new CompareOperation <TProperty>(new PropertyReference <T, TProperty>(name), new ScalarValue <TProperty>(value), op))); }
private string GetFilterText(FilterComparison filter) { if (filter == null || String.IsNullOrEmpty(filter.FieldName)) { return(""); } // catch null values if (filter.Value == null) { if (filter.Operator == FilterComparisonOperatorEnum.Equal || filter.Operator == FilterComparisonOperatorEnum.ExactlyEqual) { return(String.Format(" {0} IS NULL", Connection.EscapeObjectName(filter.FieldName))); } else if (filter.Operator == FilterComparisonOperatorEnum.NotEqual || filter.Operator == FilterComparisonOperatorEnum.ExactlyNotEqual) { return(String.Format(" {0} IS NOT NULL", Connection.EscapeObjectName(filter.FieldName))); } } FieldDefinition field = null; if (Entity != null && Entity.EntityType.IsAssignableFrom(typeof(Record))) { // an entity definition is available // try to find the filed field = Entity.FieldDefinitions.Where(f => f.DbColumnName == filter.FieldName).FirstOrDefault(); } if (field != null) { // handle the request for a known field in the current entity string text = ""; // create a SQL parameter DbParameter param = _FactoryCommand.CreateParameter(); // generate a unique parameter name from a GUID param.ParameterName = Guid.NewGuid().ToString().Replace('-', '_'); // check whether a different DbType is set if (field.DbType != null) { param.DbType = (DbType)field.DbType; } try { // get the type for the conversion (not nullable) Type notNullableType = Nullable.GetUnderlyingType(field.MemberType) ?? field.MemberType; // convert the value to the type of the member param.Value = Convert.ChangeType(filter.Value, notNullableType); } catch (Exception ex) { throw new Exception(String.Format( "Error while converting the value '{0}' into '{1}' while creating a filter for the field '{2}'.", filter.Value, field.MemberType.Name, filter.FieldName), ex); } // add the parameter to the local collection Parameters.Add(param); if (field.MemberType == typeof(string) && filter.Operator == FilterComparisonOperatorEnum.ExactlyEqual) { text = String.Format(" {0} = @{1} {2}", Connection.EscapeObjectName(filter.FieldName), param.ParameterName, GetCaseSensivityCollation()); } else if (field.MemberType == typeof(string) && filter.Operator == FilterComparisonOperatorEnum.ExactlyNotEqual) { text = String.Format(" {0} <> @{1} {2}", Connection.EscapeObjectName(filter.FieldName), param.ParameterName, GetCaseSensivityCollation()); } else { text = String.Format(" {0} {1} @{2}", Connection.EscapeObjectName(filter.FieldName), FilterUtilities.GetSqlComparisonOperator(filter.Operator), param.ParameterName); } return(text); } else { // handle the request for an unknow filed, an unknown entity type or an anonymous record data type string text = ""; // create a SQL parameter DbParameter param = _FactoryCommand.CreateParameter(); // generate a unique parameter name from a GUID param.ParameterName = Guid.NewGuid().ToString().Replace('-', '_'); param.Value = filter.Value == null ? DBNull.Value : filter.Value; // add the parameter to the local collection Parameters.Add(param); if (filter.Value is string && filter.Operator == FilterComparisonOperatorEnum.ExactlyEqual) { text = String.Format(" {0} = @{1} {2}", Connection.EscapeObjectName(filter.FieldName), param.ParameterName, GetCaseSensivityCollation()); } else if (filter.Value is string && filter.Operator == FilterComparisonOperatorEnum.ExactlyNotEqual) { text = String.Format(" {0} <> @{1} {2}", Connection.EscapeObjectName(filter.FieldName), param.ParameterName, GetCaseSensivityCollation()); } else { text = String.Format(" {0} {1} @{2}", Connection.EscapeObjectName(filter.FieldName), FilterUtilities.GetSqlComparisonOperator(filter.Operator), param.ParameterName); } return(text); } }
/// <summary> /// Appends a filter term with an OR operation. /// </summary> /// <param name="ordinal">The ordinal position of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> /// <returns>The ClassFilterExpression.</returns> public ClassFilterExpression Or(int ordinal, FilterComparison comparison, object value) { return(Or(new ClassFilterTerm(_Aspect, ordinal, comparison, value))); }
/// <summary> /// Appends a filter term with an OR operation. /// </summary> /// <param name="name">The name of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> /// <returns>The T.</returns> public EnumerableSelect <T> Or(string name, FilterComparison comparison, object value) { return(Or(new ClassFilterTerm(_Aspect, name, comparison, value))); }
/// <summary> /// Appends a filter term term with an AND operation. /// </summary> /// <param name="name">The name of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> /// <returns>The T.</returns> public ClassDelete And(string name, FilterComparison comparison, object value) { return(And(new ClassFilterTerm(_Aspect, name, comparison, value))); }
public static LogicalOperation CompareValue(string propName, object value, FilterComparison op = FilterComparison.Equal) { return(new DynamicComparation(propName, value, op)); }
public FilterAttribute(FilterComparison filterComparison, string filterProperty = null) { this.FilterComparison = filterComparison; FilterProperty = filterProperty; }
public ClassSelect <T> AppendAnd(string name, FilterComparison comparison, object value) { return(this._WhereFirst == null? Where(name, comparison, value) : And(name, comparison, value)); }
/// <summary> /// Appends a filter term with an OR operation. /// </summary> /// <param name="ordinal">The ordinal position of the member.</param> /// <param name="comparison">The comparison to make.</param> /// <param name="value">The value to compare to.</param> /// <returns>The T.</returns> public EnumerableSelect <T> Or(int ordinal, FilterComparison comparison, object value) { return(Or(new ClassFilterTerm(_Aspect, ordinal, comparison, value))); }