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)));
}
