It has been quite a while since I worked on this, but I did get it working. If I recall correctly, the issue was in the code and not in DEF settings items, and the reason it wasn't getting picked up was because a reference to an interface or class needed to be updated. This combination of code worked:
public class EventDefinitionIdValueExpressionBuilder : BaseEventDefinitionTypeExpressionBuilder<Guid>
{
public IValueAccessor RightValueAccessor { get; set; }
public Guid EventDefinitionType { get; set; }
protected override Expression<Func<Event, bool>> BuildEventExpression(
ExpressionContext expressionContext)
{
Guid eventDefinitionType = this.GetValue(expressionContext);
switch (this.ExpressionType)
{
case ExpressionType.Equal:
return (Expression<Func<Event, bool>>)(ev => ev.DefinitionId.Equals(eventDefinitionType));
case ExpressionType.NotEqual:
return (Expression<Func<Event, bool>>)(ev => !ev.DefinitionId.Equals(eventDefinitionType));
default:
throw new NotSupportedException(string.Format("Condition operator is not supported. (Condition operator: {0})", (object)this.ExpressionType));
}
}
protected override Guid GetValue(
ExpressionContext expressionContext)
{
if (this.RightValueAccessor?.ValueReader != null)
{
ReadResult readResult = this.RightValueAccessor.ValueReader.Read((object)expressionContext, new DataAccessContext());
if (readResult.WasValueRead)
{
return readResult.ReadValue as Guid? ?? Guid.Empty;
}
}
return this.EventDefinitionType;
}
}
public class EventDefinitionIdValueExpressionConverter : BaseItemModelConverter<IEventExpressionBuilder>
{
public const string FieldNameConditionOperator = "ConditionOperator";
public const string FieldNameValue = "Value";
public const string FieldNameRightValueAccessor = "RightValueAccessor";
protected readonly ExpressionTypeConverter ExpressionTypeConverter;
public EventDefinitionIdValueExpressionConverter(IItemModelRepository repository) : this(repository, new ExpressionTypeConverter())
{
}
public EventDefinitionIdValueExpressionConverter(
IItemModelRepository repository,
ExpressionTypeConverter expressionTypeConverter)
: base(repository)
{
this.ExpressionTypeConverter = expressionTypeConverter ?? new ExpressionTypeConverter();
}
protected override ConvertResult<IEventExpressionBuilder> ConvertSupportedItem(ItemModel source)
{
string conditionOperator = this.GetConditionOperator(source);
ExpressionType expressionType;
if (!this.TryGetExpressionType(conditionOperator, out expressionType))
{
return this.NegativeResult(source, "Cannot convert string condition operator to expression type. (condition operator: " + conditionOperator + ")");
}
Guid eventDefinitionId = this.GetEventDefinitionId(source);
IValueAccessor rightValueAccessor = this.GetRightValueAccessor(source);
EventDefinitionIdValueExpressionBuilder expressionBuilder = new EventDefinitionIdValueExpressionBuilder();
expressionBuilder.EventDefinitionType = eventDefinitionId;
expressionBuilder.ExpressionType = expressionType;
expressionBuilder.RightValueAccessor = rightValueAccessor;
return this.PositiveResult((IEventExpressionBuilder)expressionBuilder);
}
protected virtual IValueAccessor GetRightValueAccessor(ItemModel source) => this.ConvertReferenceToModel<IValueAccessor>(source, "RightValueAccessor");
protected virtual Guid GetEventDefinitionId(ItemModel source)
{
return this.GetGuidValue(source, "Value");
}
protected virtual string GetConditionOperator(ItemModel source) => this.GetReferenceAsModel(source, "ConditionOperator")["ItemName"].ToString();
protected bool TryGetExpressionType(string conditionOperator, out ExpressionType expressionType)
{
return Enum.TryParse<ExpressionType>(conditionOperator, true, out expressionType);
}
}
public class EventDefinitionIdValueReaderConverter : BaseItemModelConverter<IValueReader>
{
private static EventDefinitionIdValueReader _reader = new EventDefinitionIdValueReader();
public EventDefinitionIdValueReaderConverter(IItemModelRepository repository): base(repository)
{
}
protected override ConvertResult<IValueReader> ConvertSupportedItem(
ItemModel source)
{
return this.PositiveResult((IValueReader)EventDefinitionIdValueReaderConverter._reader);
}
}
public abstract class BaseEventDefinitionTypeExpressionBuilder<TValue> : IEventExpressionBuilder
{
public ExpressionType ExpressionType { get; set; }
public Expression<Func<Event, bool>> Build(ExpressionContext expressionContext)
{
Expression<Func<Event, bool>> expression = this.BuildEventExpression(expressionContext);
return Expression.Lambda<Func<Event, bool>>(expression.Body, (IEnumerable<ParameterExpression>)expression.Parameters);
}
protected abstract Expression<Func<Event, bool>> BuildEventExpression(ExpressionContext expressionContext);
protected abstract TValue GetValue(ExpressionContext expressionContext);
}
For supplementary material, I have more code examples and explanations on these posts: