public void Should_not_filter_out_fields_without_operators_when_flattened_by_model_but_flag_is_false()
{
var schema = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(new FilterSchema(FilterSchemaType.Object), "property1"),
new FilterField(FilterSchema.String, "property2"),
}.ToReadonlyList()
};
var expected = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(new FilterSchema(FilterSchemaType.Object), "property1"),
new FilterField(FilterSchema.String, "property2")
}.ToReadonlyList()
};
var actual = new QueryModel {
Schema = schema
}.Flatten(onlyWithOperators: false).Schema;
Assert.Equal(expected, actual);
}
public IReadOnlyList <ScriptingValue> Content(FilterSchema dataSchema, ScriptScope scope)
{
AddShared(scope);
AddObject("ctx", FieldDescriptions.Context, () =>
{
AddString("contentId",
FieldDescriptions.EntityId);
AddString("status",
FieldDescriptions.ContentStatus);
AddString("statusOld",
FieldDescriptions.ContentStatusOld);
AddObject("data", FieldDescriptions.ContentData, () =>
{
AddData(dataSchema);
});
AddObject("dataOld", FieldDescriptions.ContentDataOld, () =>
{
AddData(dataSchema);
});
});
return(result.OrderBy(x => x.Path).ToList());
}
public void Should_ignore_conflicts_when_flatten()
{
var schema = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(FilterSchema.Number, "property1"),
new FilterField(FilterSchema.String, "property1"),
new FilterField(FilterSchema.String, "property2"),
new FilterField(FilterSchema.String, "property2")
}.ToReadonlyList()
};
var expected = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(FilterSchema.String, "property2")
}.ToReadonlyList()
};
var actual = schema.Flatten();
Assert.Equal(expected, actual);
}
public void Should_remove_Descriptions_for_merged_fields()
{
var schema = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(FilterSchema.String, "property1", "Description1"),
new FilterField(FilterSchema.String, "property2", "Description2"),
new FilterField(FilterSchema.String, "property2", "Description3")
}.ToReadonlyList()
};
var expected = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(FilterSchema.String, "property1", "Description1"),
new FilterField(FilterSchema.String, "property2")
}.ToReadonlyList()
};
var actual = schema.Flatten();
Assert.Equal(expected, actual);
}
static QueryFromODataTests()
{
var fields = new List <FilterField>
{
new FilterField(FilterSchema.Guid, "id"),
new FilterField(FilterSchema.Guid, "idNullable", IsNullable: true),
new FilterField(FilterSchema.DateTime, "created"),
new FilterField(FilterSchema.DateTime, "createdNullable", IsNullable: true),
new FilterField(FilterSchema.Boolean, "isComicFigure"),
new FilterField(FilterSchema.Boolean, "isComicFigureNullable", IsNullable: true),
new FilterField(FilterSchema.String, "firstName"),
new FilterField(FilterSchema.String, "firstNameNullable", IsNullable: true),
new FilterField(FilterSchema.String, "lastName"),
new FilterField(FilterSchema.String, "lastNameNullable", IsNullable: true),
new FilterField(FilterSchema.Number, "age"),
new FilterField(FilterSchema.Number, "ageNullable", IsNullable: true),
new FilterField(FilterSchema.Number, "incomeMio"),
new FilterField(FilterSchema.Number, "incomeMioNullable", IsNullable: true),
new FilterField(FilterSchema.GeoObject, "geo"),
new FilterField(FilterSchema.GeoObject, "geoNullable", IsNullable: true),
new FilterField(FilterSchema.Any, "properties"),
};
var filterSchema = new FilterSchema(FilterSchemaType.Object)
{
Fields = fields.ToReadonlyList()
};
var queryModel = new QueryModel {
Schema = filterSchema
};
EdmModel = queryModel.ConvertToEdm("Squidex", "Content");
}
private static void CheckFields(FilterSchema filterSchema, Schema schema)
{
var filterProperties = AllPropertyNames(filterSchema);
void CheckField(IField field)
{
if (!field.IsForApi(true))
{
Assert.DoesNotContain(field.Name, filterProperties);
}
else
{
Assert.Contains(field.Name, filterProperties);
}
if (field is IArrayField array)
{
foreach (var nested in array.Fields)
{
CheckField(nested);
}
}
}
foreach (var field in schema.Fields)
{
CheckField(field);
}
}
private static void FillOperatorsClausesInSchema(FilterSchema schema)
{
schema.Operators = new List <Operator>()
{
new Operator()
{
Identifier = Guid.NewGuid(), Text = "equals to", Value = "=", Type = "all", IsTextControlVisible = true
},
new Operator()
{
Identifier = Guid.NewGuid(), Text = "is any of", Value = "IN", Type = "all", IsMultiSelect = true
},
new Operator()
{
Identifier = Guid.NewGuid(), Text = "contains", Value = "LIKE", Type = "varchar", IsTextControlVisible = true
},
new Operator()
{
Identifier = Guid.NewGuid(), Text = "greater than", Value = ">", Type = "int", IsTextControlVisible = true
},
new Operator()
{
Identifier = Guid.NewGuid(), Text = "lesser than", Value = "<", Type = "int", IsTextControlVisible = true
},
new Operator()
{
Identifier = Guid.NewGuid(), Text = "in list of", Value = "IN", Type = "all", IsCsvControlVisible = true
},
new Operator()
{
Identifier = Guid.NewGuid(), Text = "not in list of", Value = "NOT IN", Type = "all", IsCsvControlVisible = true
}
};
schema.Clauses = new List <TextValuePair>()
{
new TextValuePair()
{
Text = "AND", Value = "AND"
},
new TextValuePair()
{
Text = "OR", Value = "OR"
}
};
schema.SubClauses = new List <TextValuePair>()
{
new TextValuePair()
{
Text = "SUB AND", Value = "AND"
},
new TextValuePair()
{
Text = "SUB OR", Value = "OR"
}
};
schema.Filters = new List <Filter>();
}
public ScriptingCompleterTests()
{
var schema =
new Schema("simple")
.AddString(1, "my-field", Partitioning.Invariant);
dataSchema = schema.BuildDataSchema(LanguagesConfig.English.ToResolver(), ResolvedComponents.Empty);
sut = new ScriptingCompleter(new[] { scriptDescriptor1, scriptDescriptor2 });
}
public static string GetFilterSchema(int envDetailAutoId)
{
var objAdminBAL = new clsAdminBAL(strToolConnString, strToolConnType);
FilterSchema schema = objAdminBAL.GetFilterSchema(envDetailAutoId);
FillOperatorsClausesInSchema(schema);
var json = JsonConvert.SerializeObject(schema);
return(json);
}
public static FilterSchema BuildDataSchema(this Schema schema, PartitionResolver partitionResolver,
ResolvedComponents components)
{
Guard.NotNull(partitionResolver);
Guard.NotNull(components);
var fields = new List <FilterField>();
var schemaName = schema.DisplayName();
foreach (var field in schema.Fields.ForApi(true))
{
var fieldSchema = FilterVisitor.BuildProperty(field, components);
if (fieldSchema == null)
{
continue;
}
var partitioning = partitionResolver(field.Partitioning);
var partitionFields = new List <FilterField>();
foreach (var partitionKey in partitioning.AllKeys)
{
var partitionDescription = FieldPartitionDescription(field, partitioning.GetName(partitionKey) ?? partitionKey);
var partitionField = new FilterField(
fieldSchema,
partitionKey,
partitionDescription,
true);
partitionFields.Add(partitionField);
}
var filterable = new FilterField(
new FilterSchema(FilterSchemaType.Object)
{
Fields = partitionFields.ToReadonlyList()
},
field.Name,
FieldDescription(schemaName, field));
fields.Add(filterable);
}
var dataSchema = new FilterSchema(FilterSchemaType.Object)
{
Fields = fields.ToReadonlyList()
};
return(dataSchema);
}
private void AddData(FilterSchema dataSchema)
{
if (dataSchema.Fields == null)
{
return;
}
foreach (var field in dataSchema.Fields)
{
switch (field.Schema.Type)
{
case FilterSchemaType.Any:
AddAny(field.Path, field.Description);
break;
case FilterSchemaType.Boolean:
AddBoolean(field.Path, field.Description);
break;
case FilterSchemaType.DateTime:
AddString(field.Path, field.Description);
break;
case FilterSchemaType.GeoObject:
AddObject(field.Path, field.Description);
break;
case FilterSchemaType.Guid:
AddString(field.Path, field.Description);
break;
case FilterSchemaType.Number:
AddNumber(field.Path, field.Description);
break;
case FilterSchemaType.Object:
AddObject(field.Path, field.Description);
break;
case FilterSchemaType.ObjectArray:
AddArray(field.Path, field.Description);
break;
case FilterSchemaType.String:
AddString(field.Path, field.Description);
break;
case FilterSchemaType.StringArray:
AddArray(field.Path, field.Description);
break;
}
}
}
private static HashSet <string> AllPropertyNames(FilterSchema schema)
{
var result = new HashSet <string>();
void AddProperties(FilterSchema current)
{
if (current == null)
{
return;
}
foreach (var field in current.Fields.OrEmpty())
{
result.Add(field.Path);
AddProperties(field.Schema);
}
}
AddProperties(schema);
return(result);
}
public void Should_filter_out_fields_by_predicate_when_flatten()
{
var schema = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(new FilterSchema(FilterSchemaType.Object), "property1"),
new FilterField(FilterSchema.String, "property2"),
}.ToReadonlyList()
};
var expected = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(FilterSchema.String, "property2")
}.ToReadonlyList()
};
var actual = schema.Flatten(predicate: x => x.Type != FilterSchemaType.Object);
Assert.Equal(expected, actual);
}
public void Should_flatten_schema()
{
var schema = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(FilterSchema.Number, "nested3")
}.ToReadonlyList()
}, "nested2")
}.ToReadonlyList()
}, "nested1")
}.ToReadonlyList()
};
var expected = new FilterSchema(FilterSchemaType.Object)
{
Fields = new[]
{
new FilterField(new FilterSchema(FilterSchemaType.Object), "nested1"),
new FilterField(new FilterSchema(FilterSchemaType.Object), "nested1.nested2"),
new FilterField(new FilterSchema(FilterSchemaType.Number), "nested1.nested2.nested3")
}.ToReadonlyList()
};
var actual = schema.Flatten();
Assert.Equal(expected, actual);
}
public IReadOnlyList <ScriptingValue> ContentTrigger(FilterSchema dataSchema)
{
Guard.NotNull(dataSchema, nameof(dataSchema));
return(new Process(descriptors).Content(dataSchema, ScriptScope.ContentTrigger));
}
public static EdmModel ConvertToEdm(this QueryModel queryModel, string modelName, string name)
{
var model = new EdmModel();
var entityType = new EdmEntityType(modelName, name);
var entityPath = new Stack <string>();
void Convert(EdmStructuredType target, FilterSchema schema)
{
if (schema.Fields == null)
{
return;
}
foreach (var field in FilterSchema.GetConflictFreeFields(schema.Fields))
{
var fieldName = field.Path.EscapeEdmField();
switch (field.Schema.Type)
{
case FilterSchemaType.Boolean:
target.AddStructuralProperty(fieldName, EdmPrimitiveTypeKind.Boolean, field.IsNullable);
break;
case FilterSchemaType.DateTime:
target.AddStructuralProperty(fieldName, EdmPrimitiveTypeKind.DateTimeOffset, field.IsNullable);
break;
case FilterSchemaType.GeoObject:
target.AddStructuralProperty(fieldName, EdmPrimitiveTypeKind.GeographyPoint, field.IsNullable);
break;
case FilterSchemaType.Guid:
target.AddStructuralProperty(fieldName, EdmPrimitiveTypeKind.Guid, field.IsNullable);
break;
case FilterSchemaType.Number:
target.AddStructuralProperty(fieldName, EdmPrimitiveTypeKind.Double, field.IsNullable);
break;
case FilterSchemaType.String:
case FilterSchemaType.StringArray:
target.AddStructuralProperty(fieldName, EdmPrimitiveTypeKind.String, field.IsNullable);
break;
case FilterSchemaType.Object:
case FilterSchemaType.ObjectArray:
{
if (field.Schema.Fields == null || field.Schema.Fields.Count == 0 || entityPath.Count >= MaxDepth)
{
break;
}
entityPath.Push(fieldName);
var typeName = string.Join("_", entityPath.Reverse().Select(x => x.EscapeEdmField().ToPascalCase()));
var result = model.SchemaElements.OfType <EdmComplexType>().FirstOrDefault(x => x.Name == typeName);
if (result == null)
{
result = new EdmComplexType(modelName, typeName);
model.AddElement(result);
Convert(result, field.Schema);
}
target.AddStructuralProperty(fieldName, new EdmComplexTypeReference(result, field.IsNullable));
entityPath.Pop();
break;
}
case FilterSchemaType.Any:
{
var result = model.SchemaElements.OfType <EdmComplexType>().FirstOrDefault(x => x.Name == "Any");
if (result == null)
{
result = new EdmComplexType("Squidex", "Any", null, false, true);
model.AddElement(result);
}
target.AddStructuralProperty(fieldName, new EdmComplexTypeReference(result, field.IsNullable));
break;
}
}
}
}
Convert(entityType, queryModel.Schema);
var container = new EdmEntityContainer("Squidex", "Container");
container.AddEntitySet("ContentSet", entityType);
model.AddElement(container);
model.AddElement(entityType);
return(model);
}
public static QueryModel Build(Schema?schema, PartitionResolver partitionResolver, ResolvedComponents components)
{
var fields = new List <FilterField>
{
new FilterField(FilterSchema.String, "id")
{
Description = FieldDescriptions.EntityId
},
new FilterField(FilterSchema.Boolean, "isDeleted")
{
Description = FieldDescriptions.EntityIsDeleted
},
new FilterField(FilterSchema.DateTime, "created")
{
Description = FieldDescriptions.EntityCreated
},
new FilterField(SharedSchemas.User, "createdBy")
{
Description = FieldDescriptions.EntityCreatedBy
},
new FilterField(FilterSchema.DateTime, "lastModified")
{
Description = FieldDescriptions.EntityLastModified
},
new FilterField(SharedSchemas.User, "lastModifiedBy")
{
Description = FieldDescriptions.EntityLastModifiedBy
},
new FilterField(FilterSchema.Number, "version")
{
Description = FieldDescriptions.EntityVersion
},
new FilterField(SharedSchemas.Status, "status")
{
Description = FieldDescriptions.ContentStatus,
},
new FilterField(SharedSchemas.Status, "newStatus", IsNullable: true)
{
Description = FieldDescriptions.ContentNewStatus
}
};
if (schema != null)
{
var dataSchema = schema.BuildDataSchema(partitionResolver, components);
fields.Add(new FilterField(dataSchema, "data")
{
Description = FieldDescriptions.ContentData
});
}
var filterSchema = new FilterSchema(FilterSchemaType.Object)
{
Fields = fields.ToReadonlyList()
};
return(new QueryModel {
Schema = filterSchema
});
}
public IReadOnlyList <ScriptingValue> ContentTrigger(FilterSchema dataSchema)
{
Guard.NotNull(dataSchema);
return(new Process(descriptors, dataSchema.Flatten()).ContentTrigger());
}
public static QueryModel Build()
{
var fields = new List <FilterField>
{
new FilterField(FilterSchema.String, "id")
{
Description = FieldDescriptions.EntityId
},
new FilterField(FilterSchema.Boolean, "isDeleted")
{
Description = FieldDescriptions.EntityIsDeleted
},
new FilterField(FilterSchema.DateTime, "created")
{
Description = FieldDescriptions.EntityCreated
},
new FilterField(SharedSchemas.User, "createdBy")
{
Description = FieldDescriptions.EntityCreatedBy
},
new FilterField(FilterSchema.DateTime, "lastModified")
{
Description = FieldDescriptions.EntityLastModified
},
new FilterField(SharedSchemas.User, "lastModifiedBy")
{
Description = FieldDescriptions.EntityLastModifiedBy
},
new FilterField(FilterSchema.String, "status")
{
Description = FieldDescriptions.ContentStatus
},
new FilterField(FilterSchema.String, "version")
{
Description = FieldDescriptions.EntityVersion
},
new FilterField(FilterSchema.String, "fileHash")
{
Description = FieldDescriptions.AssetFileHash
},
new FilterField(FilterSchema.String, "fileName")
{
Description = FieldDescriptions.AssetFileName
},
new FilterField(FilterSchema.Number, "fileSize")
{
Description = FieldDescriptions.AssetFileSize
},
new FilterField(FilterSchema.Number, "fileVersion")
{
Description = FieldDescriptions.AssetFileVersion
},
new FilterField(FilterSchema.Boolean, "isProtected")
{
Description = FieldDescriptions.AssetIsProtected
},
new FilterField(FilterSchema.Any, "metadata")
{
Description = FieldDescriptions.AssetMetadata
},
new FilterField(FilterSchema.String, "mimeType")
{
Description = FieldDescriptions.AssetMimeType
},
new FilterField(FilterSchema.String, "slug")
{
Description = FieldDescriptions.AssetSlug
},
new FilterField(FilterSchema.StringArray, "tags")
{
Description = FieldDescriptions.AssetTags
},
new FilterField(FilterSchema.String, "type")
{
Description = FieldDescriptions.AssetType
}
};
var schema = new FilterSchema(FilterSchemaType.Object)
{
Fields = fields.ToReadonlyList()
};
return(new QueryModel {
Schema = schema
});
}
public static IEnumerable <FilterField> GetMatchingFields(this PropertyPath path, FilterSchema schema, List <string> errors)
{
var lastIndex = path.Count - 1;
List <FilterField>?result = null;
void Check(int index, FilterSchema schema)
{
if (schema.Fields == null)
{
return;
}
var fields = schema.Fields.Where(x => x.Path == path[index]);
foreach (var field in fields)
{
if (index == lastIndex || field.Schema.Type == FilterSchemaType.Any)
{
result ??= new List <FilterField>();
result.Add(field);
}
else
{
Check(index + 1, field.Schema);
}
}
}
Check(0, schema);
if (result == null)
{
errors.Add(Errors.InvalidPath(path.ToString()));
}
return(result as IEnumerable <FilterField> ?? Array.Empty <FilterField>());
}
