public override FilterNode <ClrValue> Visit(CompareFilter <IJsonValue> nodeIn)
{
CompareFilter <ClrValue> result = null;
if (nodeIn.Path.TryGetProperty(schema, errors, out var property))
{
var isValidOperator = OperatorValidator.IsAllowedOperator(property, nodeIn.Operator);
if (!isValidOperator)
{
errors.Add($"{nodeIn.Operator} is not a valid operator for type {property.Type} at {nodeIn.Path}.");
}
var value = ValueConverter.Convert(property, nodeIn.Value, nodeIn.Path, errors);
if (value != null && isValidOperator)
{
if (value.IsList && nodeIn.Operator != CompareOperator.In)
{
errors.Add($"Array value is not allowed for '{nodeIn.Operator}' operator and path '{nodeIn.Path}'.");
}
result = new CompareFilter <ClrValue>(nodeIn.Path, nodeIn.Operator, value);
}
}
result = result ?? new CompareFilter <ClrValue>(nodeIn.Path, nodeIn.Operator, ClrValue.Null);
return(result);
}
public override FilterNode <ClrValue> Visit(CompareFilter <ClrValue> nodeIn)
{
CompareFilter <ClrValue> result;
var path = pathConverter(nodeIn.Path);
var value = nodeIn.Value.Value;
if (value is Instant &&
!string.Equals(path[0], "mt", StringComparison.OrdinalIgnoreCase) &&
!string.Equals(path[0], "ct", StringComparison.OrdinalIgnoreCase))
{
result = new CompareFilter <ClrValue>(path, nodeIn.Operator, value.ToString());
}
else
{
result = new CompareFilter <ClrValue>(path, nodeIn.Operator, nodeIn.Value);
}
if (value is List <Guid> guidList)
{
result = new CompareFilter <ClrValue>(path, nodeIn.Operator, guidList.Select(x => x.ToString()).ToList());
}
else if (value is Guid guid)
{
result = new CompareFilter <ClrValue>(path, nodeIn.Operator, guid.ToString());
}
return(result);
}
public override FilterDefinition <T> Visit(CompareFilter <ClrValue> nodeIn, None args)
{
var propertyName = nodeIn.Path.ToString();
var value = nodeIn.Value.Value;
switch (nodeIn.Operator)
{
case CompareOperator.Empty:
return(Filter.Or(
Filter.Exists(propertyName, false),
Filter.Eq <object?>(propertyName, null),
Filter.Eq <object?>(propertyName, string.Empty),
Filter.Size(propertyName, 0)));
case CompareOperator.Exists:
return(Filter.And(
Filter.Exists(propertyName, true),
Filter.Ne <object?>(propertyName, null)));
case CompareOperator.Matchs:
return(Filter.Regex(propertyName, BuildMatchRegex(nodeIn)));
case CompareOperator.StartsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s)));
case CompareOperator.Contains:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s)));
case CompareOperator.EndsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$")));
case CompareOperator.Equals:
return(Filter.Eq(propertyName, value));
case CompareOperator.GreaterThan:
return(Filter.Gt(propertyName, value));
case CompareOperator.GreaterThanOrEqual:
return(Filter.Gte(propertyName, value));
case CompareOperator.LessThan:
return(Filter.Lt(propertyName, value));
case CompareOperator.LessThanOrEqual:
return(Filter.Lte(propertyName, value));
case CompareOperator.NotEquals:
return(Filter.Ne(propertyName, value));
case CompareOperator.In:
return(Filter.In(propertyName, ((IList)value !).OfType <object>()));
}
throw new NotSupportedException();
}
private static BsonRegularExpression BuildMatchRegex(CompareFilter <ClrValue> node)
{
var value = node.Value.Value?.ToString();
if (value == null)
{
return(new BsonRegularExpression("null", "i"));
}
if (value.Length > 3 && ((value[0] == '/' && value[^ 1] == '/') || value[^ 2] == '/'))
public override FilterNode <ClrValue> Visit(CompareFilter <ClrValue> nodeIn, Args args)
{
var result = nodeIn;
var(path, op, value) = nodeIn;
var clrValue = value.Value;
if (string.Equals(path[0], "id", StringComparison.OrdinalIgnoreCase))
{
path = "_id";
if (clrValue is List <string> idList)
{
value = idList.Select(x => DomainId.Combine(args.AppId, DomainId.Create(x)).ToString()).ToList();
}
else if (clrValue is string id)
{
value = DomainId.Combine(args.AppId, DomainId.Create(id)).ToString();
}
else if (clrValue is List <Guid> guidIdList)
{
value = guidIdList.Select(x => DomainId.Combine(args.AppId, DomainId.Create(x)).ToString()).ToList();
}
else if (clrValue is Guid guidId)
{
value = DomainId.Combine(args.AppId, DomainId.Create(guidId)).ToString();
}
}
else
{
path = Adapt.MapPath(path);
if (clrValue is List <Guid> guidList)
{
value = guidList.Select(x => x.ToString()).ToList();
}
else if (clrValue is Guid guid)
{
value = guid.ToString();
}
else if (clrValue is Instant &&
!string.Equals(path[0], "mt", StringComparison.OrdinalIgnoreCase) &&
!string.Equals(path[0], "ct", StringComparison.OrdinalIgnoreCase))
{
value = clrValue.ToString();
}
}
return(result with {
Path = path, Value = value
});
}
public override FilterNode <ClrValue> Visit(CompareFilter <IJsonValue> nodeIn, Args args)
{
CompareFilter <ClrValue>?result = null;
if (nodeIn.Path.TryGetProperty(args.Schema, args.Errors, out var property))
{
var isValidOperator = OperatorValidator.IsAllowedOperator(property, nodeIn.Operator);
if (!isValidOperator)
{
var name = property.Type.ToString();
if (!string.IsNullOrWhiteSpace(property.Format))
{
name = $"{name}({property.Format})";
}
args.Errors.Add($"'{nodeIn.Operator}' is not a valid operator for type {name} at '{nodeIn.Path}'.");
}
var value = ValueConverter.Convert(property, nodeIn.Value, nodeIn.Path, args.Errors);
if (value != null && isValidOperator)
{
if (nodeIn.Operator == CompareOperator.In)
{
if (!value.IsList)
{
value = value.ToList();
}
}
else
{
if (value.IsList)
{
args.Errors.Add($"Array value is not allowed for '{nodeIn.Operator}' operator and path '{nodeIn.Path}'.");
}
}
if (nodeIn.Operator == CompareOperator.Matchs && value.Value?.ToString()?.IsValidRegex() != true)
{
args.Errors.Add($"{value} is not a valid regular expression.");
}
result = new CompareFilter <ClrValue>(nodeIn.Path, nodeIn.Operator, value);
}
}
result ??= new CompareFilter <ClrValue>(nodeIn.Path, nodeIn.Operator, ClrValue.Null);
return(result);
}
public override FilterNode <ClrValue> Visit(CompareFilter <ClrValue> nodeIn, None args)
{
if (string.Equals(nodeIn.Path[0], "id", StringComparison.OrdinalIgnoreCase))
{
return(nodeIn);
}
var path = Adapt.MapPath(nodeIn.Path);
return(nodeIn with {
Path = path
});
}
public override FilterNode <ClrValue> Visit(CompareFilter <ClrValue> nodeIn)
{
if (string.Equals(nodeIn.Path[0], nameof(IAssetEntity.Tags), StringComparison.OrdinalIgnoreCase) && nodeIn.Value.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 CompareFilter <ClrValue>(nodeIn.Path, nodeIn.Operator, normalized));
}
}
return(nodeIn);
}
public override FilterNode <ClrValue>?Visit(CompareFilter <ClrValue> nodeIn)
{
if (nodeIn.Value.Value is string stringValue && IsDataPath(nodeIn.Path) && IsTagField(nodeIn.Path))
{
var tagNames = Task.Run(() => tagService.GetTagIdsAsync(appId, TagGroups.Schemas(schema.Id), HashSet.Of(stringValue))).Result;
if (tagNames.TryGetValue(stringValue, out var normalized))
{
return(new CompareFilter <ClrValue>(nodeIn.Path, nodeIn.Operator, normalized));
}
}
return(nodeIn);
}
private static Expression BuildCompare <T>(CompareFilter filter, Expression parameter)
{
var prp = filter.PropertyName.Split(".");
var prpAccess = Expression.Property(parameter, prp[0]);
if (prp.Length > 1)
{
for (int a = 1; a < prp.Length; a++)
{
prpAccess = Expression.Property(prpAccess, prp[a]);
}
}
var body = CompareExpression(filter.Operator, prpAccess, filter.Value, filter.Value2);
return(body);
}
public static List<SMBLevelCompare> CompareLevels(List<SMBLevel> levels1, List<SMBLevel> levels2, CompareFilter compareFilter)
{
return (from levels in levels1.Zip(levels2, (x1, x2) => new { x1, x2 })
where levels.x1.IsCompleted && levels.x2.IsCompleted
let difference = levels.x1.Time - levels.x2.Time
where compareFilter == CompareFilter.All || (compareFilter == CompareFilter.Bigger && difference > 0)
|| (compareFilter == CompareFilter.Smaller && difference < 0)
orderby difference descending
select new SMBLevelCompare
{
LevelName = levels.x1.LevelNameWithNumber,
Time1 = levels.x1.Time,
Time2 = levels.x2.Time,
Difference = difference,
ParTime = levels.x1.ParTime
}).ToList();
}
public override FilterDefinition <T> Visit(CompareFilter <ClrValue> nodeIn)
{
var propertyName = nodeIn.Path.ToString();
switch (nodeIn.Operator)
{
case CompareOperator.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 CompareOperator.StartsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => "^" + s)));
case CompareOperator.Contains:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s)));
case CompareOperator.EndsWith:
return(Filter.Regex(propertyName, BuildRegex(nodeIn, s => s + "$")));
case CompareOperator.Equals:
return(Filter.Eq(propertyName, nodeIn.Value.Value));
case CompareOperator.GreaterThan:
return(Filter.Gt(propertyName, nodeIn.Value.Value));
case CompareOperator.GreaterThanOrEqual:
return(Filter.Gte(propertyName, nodeIn.Value.Value));
case CompareOperator.LessThan:
return(Filter.Lt(propertyName, nodeIn.Value.Value));
case CompareOperator.LessThanOrEqual:
return(Filter.Lte(propertyName, nodeIn.Value.Value));
case CompareOperator.NotEquals:
return(Filter.Ne(propertyName, nodeIn.Value.Value));
case CompareOperator.In:
return(Filter.In(propertyName, ((IList)nodeIn.Value.Value).OfType <object>()));
}
throw new NotSupportedException();
}
public override async ValueTask <FilterNode <ClrValue>?> Visit(CompareFilter <ClrValue> nodeIn, Args args)
{
if (nodeIn.Value.Value is FilterSphere sphere)
{
var field = string.Join(".", nodeIn.Path.Skip(1));
var searchQuery = new GeoQuery(args.Schema.Id, field, sphere.Latitude, sphere.Longitude, sphere.Radius, 1000);
var searchScope = args.Context.Scope();
var ids = await args.TextIndex.SearchAsync(args.Context.App, searchQuery, searchScope);
if (ids == null || ids.Count == 0)
{
return(ClrFilter.Eq("id", "__notfound__"));
}
return(ClrFilter.In("id", ids.Select(x => x.ToString()).ToList()));
}
return(nodeIn);
}
public override FilterNode <TValue>?Visit(CompareFilter <TValue> nodeIn)
{
return(new CompareFilter <TValue>(nodeIn.Path.ToFirstPascalCase(), nodeIn.Operator, nodeIn.Value));
}
public override FilterNode <TValue>?Visit(CompareFilter <TValue> nodeIn, TArgs args)
{
return(nodeIn);
}
public virtual T Visit(CompareFilter <TValue> nodeIn, TArgs args)
{
throw new NotImplementedException();
}
private static BsonRegularExpression BuildRegex(CompareFilter <ClrValue> node, Func <string, string> formatter)
{
return(new BsonRegularExpression(formatter(node.Value.Value.ToString()), "i"));
}
public override FilterNode <TValue>?Visit(CompareFilter <TValue> nodeIn, None args)
{
return(nodeIn with {
Path = nodeIn.Path.ToFirstPascalCase()
});
}
public void And(string Column, CompareFilter comp, object value)
{
string cc = "";
if (comp == CompareFilter.Like)
{
cc = " LIKE ";
}
else if (comp == CompareFilter.NotLike)
{
cc = " NOT LIKE ";
}
else if (comp == CompareFilter.Equal)
{
cc = " = ";
}
else if (comp == CompareFilter.NotEqual)
{
cc = " <> ";
}
else if (comp == CompareFilter.In)
{
cc = " IN ";
}
else if (comp == CompareFilter.NotIn)
{
cc = " NOT IN ";
}
else if (comp == CompareFilter.Null)
{
cc = " NULL ";
}
else if (comp == CompareFilter.NotNull)
{
cc = " NOT NULL ";
}
else if (comp == CompareFilter.GreaterThan)
{
cc = " > ";
}
else if (comp == CompareFilter.GreaterThanOrEqual)
{
cc = " >= ";
}
else if (comp == CompareFilter.LessThan)
{
cc = " < ";
}
else if (comp == CompareFilter.LessThanOrEqual)
{
cc = " <= ";
}
if (IsNew)
{
IsNew = false;
if (value != null)
{
if (comp == CompareFilter.Like || comp == CompareFilter.NotLike)
{
q.Where(Column + " " + cc + " N'%" + value.ToString() + "%'", null);
}
else if (comp == CompareFilter.In || comp == CompareFilter.NotIn)
{
q.Where(Column + " " + cc + " (@0)", value);
}
else
{
q.Where(Column + " " + cc + " @0", value);
}
}
else
{
q.Where(Column + " " + cc);
}
}
else
{
q.Append(" AND ");
if (value != null)
{
if (comp == CompareFilter.Like || comp == CompareFilter.NotLike)
{
q.Append(Column + " " + cc + " N'%" + value.ToString() + "%'", null);
}
else if (comp == CompareFilter.In || comp == CompareFilter.NotIn)
{
q.Append(Column + " " + cc + " (@0)", value);
}
else
{
q.Append(Column + " " + cc + " @0", value);
}
}
else
{
q.Append(Column + " " + cc);
}
}
}
public override ValueTask <FilterNode <TValue>?> Visit(CompareFilter <TValue> nodeIn, TArgs args)
{
return(new ValueTask <FilterNode <TValue>?>(nodeIn));
}