public void ShouldConvertEntityToCorrectJson()
{
Guid leftId = Guid.NewGuid();
Guid rightId = Guid.NewGuid();
var left = new FilterProperty
{
IsConform = true,
Value = "This is a test left",
ItemId = leftId
};
var right = new FilterProperty
{
IsConform = true,
Value = "This is a test right",
ItemId = rightId
};
var combination = new FilterCombination
{
RightFilter = right,
LeftFilter = left,
Type = FormFilterType.And
};
string jsonTest = JsonConvert.SerializeObject(combination);
Assert.AreEqual("{\"EntityDiscriminator\":\"FilterCombination\",\"Type\":0,\"RightFilter\":{\"EntityDiscriminator\":\"FilterProperty\",\"IsConform\":true,\"Value\":\"This is a test right\",\"NotApplicable\":false,\"ItemId\":\"" +
rightId + "\",\"Id\":\"" + right.Id + "\",\"EntityVersion\":0,\"Deleted\":false,\"EntityCreationDate\":\"0001-01-01T00:00:00\",\"EntityModificationDate\":\"0001-01-01T00:00:00\",\"EntityCreationUser\":\"00000000-0000-0000-0000-000000000000\"}," +
"\"LeftFilter\":{\"EntityDiscriminator\":\"FilterProperty\",\"IsConform\":true,\"Value\":\"This is a test left\",\"NotApplicable\":false,\"ItemId\":\"" + leftId +
"\",\"Id\":\"" + left.Id + "\",\"EntityVersion\":0,\"Deleted\":false,\"EntityCreationDate\":\"0001-01-01T00:00:00\",\"EntityModificationDate\":\"0001-01-01T00:00:00\",\"EntityCreationUser\":\"00000000-0000-0000-0000-000000000000\"}," +
"\"Id\":\"" + combination.Id + "\",\"EntityVersion\":0,\"Deleted\":false,\"EntityCreationDate\":\"0001-01-01T00:00:00\",\"EntityModificationDate\":\"0001-01-01T00:00:00\",\"EntityCreationUser\":\"00000000-0000-0000-0000-000000000000\"}", jsonTest);
}
private static void CheckVisibleConditionEquality(FormFilterCondition templateCondition, FormFilterCondition formCondition, FormTemplate template, Form form)
{
if (templateCondition == null)
{
Assert.IsNull(formCondition);
return;
}
Assert.AreEqual(templateCondition.GetType(), formCondition.GetType());
FilterProperty propertyFilter = templateCondition as FilterProperty;
if (propertyFilter != null)
{
FilterProperty formProperty = (FilterProperty)formCondition;
Assert.AreEqual(propertyFilter.IsConform, formProperty.IsConform);
Assert.AreEqual(propertyFilter.Value, formProperty.Value);
Assert.AreEqual(propertyFilter.NotApplicable, formProperty.NotApplicable);
Guid itemId = form.Items.Find((item) => item.QuestionId == propertyFilter.ItemId).Id;
Assert.AreEqual(itemId, formProperty.ItemId);
}
else
{
FilterCombination combination = (FilterCombination)templateCondition;
FilterCombination formComb = (FilterCombination)formCondition;
Assert.AreEqual(combination.Type, formComb.Type);
CheckVisibleConditionEquality(combination.LeftFilter, formComb.LeftFilter, template, form);
CheckVisibleConditionEquality(combination.RightFilter, formComb.RightFilter, template, form);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
try
{
if (reader.TokenType == JsonToken.Null)
{
return(null);
}
JObject jo = JObject.Load(reader);
if (typeof(Entity).IsAssignableFrom(objectType))
{
Entity entity = null;
if (jo.ContainsKey("EntityDiscriminator"))
{
var entityDiscriminatorValue = jo["EntityDiscriminator"].Value <string>();
switch (entityDiscriminatorValue)
{
case "Note":
entity = new Note();
break;
case "Form":
entity = new Form();
break;
case "FilterProperty":
entity = new FilterProperty();
break;
case "FilterCombination":
entity = new FilterCombination();
break;
default:
throw new Exception("EntityDiscriminator " + entityDiscriminatorValue + " not managed in the serialization");
}
}
else
{
entity = (Entity)Activator.CreateInstance(objectType);
}
serializer.Populate(jo.CreateReader(), entity);
return(entity);
}
else
{
throw new Exception("Converter used with not managed type " + objectType?.Name);
}
}
catch (Exception)
{
return(null);
}
}
public override FilterExpression Read(ref Utf8JsonReader reader, Type typeToConvert, JsonSerializerOptions options)
{
if (reader.TokenType != JsonTokenType.StartObject)
{
throw new JsonException();
}
reader.Read();
if (reader.TokenType != JsonTokenType.PropertyName)
{
throw new JsonException();
}
string propertyName = reader.GetString();
if (propertyName != Kind)
{
throw new JsonException();
}
reader.Read();
if (reader.TokenType != JsonTokenType.String)
{
throw new JsonException();
}
var expressionKind = Enum.Parse <FilterExpressionKind>(reader.GetString());
FilterCombination filterCombination = default(FilterCombination);
FilterExpression leftExpression = null, rightExpression = null, subExpression = null;
string filterPath = null, value = null;
FilterOperation filterOperation = default(FilterOperation);
bool matchCase = false, matchWholeWord = false;
while (reader.Read())
{
if (reader.TokenType == JsonTokenType.EndObject)
{
switch (expressionKind)
{
case FilterExpressionKind.Binary:
return(new FilterBinaryExpression(filterCombination, leftExpression, rightExpression));
case FilterExpressionKind.Not:
return(new FilterNotExpression(subExpression));
case FilterExpressionKind.Text:
return(new FilterTextExpression(filterPath, filterOperation, value, matchCase, matchWholeWord));
case FilterExpressionKind.Operation:
return(new FilterOperationExpression(filterPath, filterOperation, value));
}
}
if (reader.TokenType == JsonTokenType.PropertyName)
{
propertyName = reader.GetString();
reader.Read();
switch (expressionKind)
{
case FilterExpressionKind.Binary:
switch (propertyName)
{
case nameof(FilterBinaryExpression.FilterCombination):
filterCombination = Enum.Parse <FilterCombination>(reader.GetString());
break;
case nameof(FilterBinaryExpression.LeftExpression):
leftExpression = JsonSerializer.Deserialize <FilterExpression>(ref reader, options);
break;
case nameof(FilterBinaryExpression.RightExpression):
rightExpression = JsonSerializer.Deserialize <FilterExpression>(ref reader, options);
break;
}
break;
case FilterExpressionKind.Not:
subExpression = JsonSerializer.Deserialize <FilterExpression>(ref reader, options);
break;
case FilterExpressionKind.Text:
switch (propertyName)
{
case nameof(FilterTextExpression.FilterPath):
filterPath = reader.GetString();
break;
case nameof(FilterTextExpression.FilterOperation):
filterOperation = Enum.Parse <FilterOperation>(reader.GetString());
break;
case nameof(FilterTextExpression.Value):
value = reader.GetString();
break;
case nameof(FilterTextExpression.MatchCase):
matchCase = reader.GetBoolean();
break;
case nameof(FilterTextExpression.MatchWholeWord):
matchWholeWord = reader.GetBoolean();
break;
}
break;
case FilterExpressionKind.Operation:
switch (propertyName)
{
case nameof(FilterOperationExpression.FilterPath):
filterPath = reader.GetString();
break;
case nameof(FilterOperationExpression.FilterOperation):
filterOperation = Enum.Parse <FilterOperation>(reader.GetString());
break;
case nameof(FilterOperationExpression.Value):
value = reader.GetString();
break;
}
break;
}
}
}
throw new JsonException();
}
