/// <exception cref="NotSupportedException" />
/// <exception cref="InvalidOperationException" />
private JSchema GetVirtualFieldSchema(
BaseVirtualField baseVirtualField, Content definition, SchemaContext context)
{
if (baseVirtualField is VirtualMultiEntityField virtualMultiEntityField)
{
var boundFieldKey = Tuple.Create(definition, virtualMultiEntityField.Path);
Field boundField = context.VirtualFields[boundFieldKey];
var contentForArrayFields = ((EntityField)boundField).Content;
var itemSchema = new JSchema { Type = JSchemaType.Object };
foreach (BaseVirtualField childField in virtualMultiEntityField.Fields)
{
JSchema childfieldSchema = GetVirtualFieldSchema(childField, contentForArrayFields, context);
itemSchema.Properties[childField.FieldName] = childfieldSchema;
}
return new JSchema { Type = JSchemaType.Array, Items = { itemSchema } };
}
else if (baseVirtualField is VirtualEntityField virtualEntityField)
{
BaseVirtualField[] fields = virtualEntityField.Fields;
var virtualEntityFieldSchema = new JSchema { Type = JSchemaType.Object };
foreach (BaseVirtualField childField in fields)
{
JSchema childfieldSchema = GetVirtualFieldSchema(childField, definition, context);
virtualEntityFieldSchema.Properties[childField.FieldName] = childfieldSchema;
}
return virtualEntityFieldSchema;
}
else if (baseVirtualField is VirtualField virtualField)
{
if (virtualField.Converter != null)
{
return new JSchema { Type = ConvertTypeToJsType(virtualField.Converter.OutputType) };
}
else
{
var virtualFieldKey = Tuple.Create(definition, virtualField.Path);
return GetFieldSchema(context.VirtualFields[virtualFieldKey], null, context, false);
}
}
else
{
throw new NotSupportedException($"Field type {baseVirtualField.GetType()} is not supported");
}
}
private void InitVirtualField(BaseVirtualField virt)
{
if (virt is VirtualField virtCommon)
{
ObjectToRemovePath = virtCommon.ObjectToRemovePath;
VirtualPath = virtCommon.Path;
FieldType = FieldDefinitionType.VirtualField;
}
FieldType = GetVirtualFieldType(virt);
}
public FieldDefinitionType GetVirtualFieldType(BaseVirtualField virt)
{
switch (virt)
{
case VirtualMultiEntityField vmef:
return(FieldDefinitionType.VirtualMultiEntityField);
case VirtualEntityField vef:
return(FieldDefinitionType.VirtualEntityField);
case VirtualField vf:
return(FieldDefinitionType.VirtualField);
default:
throw new ArgumentException(nameof(virt));
}
}
private void ProcessVirtualField(
BaseVirtualField baseVirtualField, Content definition, VirtualFieldContext context)
{
if (baseVirtualField is VirtualMultiEntityField virtualMultiEntityField)
{
string path = virtualMultiEntityField.Path;
var virtualFieldKey = Tuple.Create(definition, path);
if (context.VirtualFields.ContainsKey(virtualFieldKey))
{
return;
}
Field foundField = _virtualFieldPathEvaluator
.GetFieldByPath(path, definition, out bool hasFilter, out Content parent);
if (!hasFilter)
{
context.IgnoredFields.Add(Tuple.Create(parent, foundField));
}
context.VirtualFields[virtualFieldKey] = foundField;
if (foundField is EntityField foundEntityField)
{
foreach (BaseVirtualField childField in virtualMultiEntityField.Fields)
{
ProcessVirtualField(childField, foundEntityField.Content, context);
}
}
else
{
throw new InvalidOperationException(
"В Path VirtualMultiEntityField должны быть только поля EntityField или наследники");
}
}
else if (baseVirtualField is VirtualEntityField virtualEntityField)
{
foreach (BaseVirtualField childField in virtualEntityField.Fields)
{
ProcessVirtualField(childField, definition, context);
}
}
else if (baseVirtualField is VirtualField virtualField)
{
string path = virtualField.Path;
var virtualFieldKey = Tuple.Create(definition, path);
if (context.VirtualFields.ContainsKey(virtualFieldKey))
{
return;
}
Field fieldToMove = _virtualFieldPathEvaluator
.GetFieldByPath(path, definition, out bool hasFilter, out Content parent);
if (!hasFilter)
{
context.IgnoredFields.Add(Tuple.Create(parent, fieldToMove));
}
context.VirtualFields[virtualFieldKey] = fieldToMove;
}
}
