public void Remove(IFilterDefinition filterElement)
{
if (Filters != null)
{
Filters.Remove(filterElement);
SetFilterMethod();
}
}
public void FluentBuilderExamples()
{
_myFilter = null; // TODO
_myAppender = Append.To.Console(c => c.Targeting.ConsoleOut());
_myLayout = Layout.Using.ExceptionMessage();
_myErrorHandler = Handle.Errors.OnlyOnce(h => h.PrefixedBy("ERROR"));
_myRenderer = null; // TODO
}
/// <summary>
/// Converts the <see cref="IFilterDefinition" /> to <see cref="AbstractFilterDefinition" />.
/// </summary>
/// <param name="filterDefinition">The <see cref="IFilterDefinition" />.</param>
/// <returns>Converted <see cref="AbstractFilterDefinition" />.</returns>
public static AbstractFilterDefinition ToStoreRepresentation(this IFilterDefinition filterDefinition)
{
return(filterDefinition switch
{
TypeFilterWithEventSourcePartitionDefinition definition =>
new TypePartitionFilterDefinition(definition.Types.Select(_ => _.Value)),
PublicFilterDefinition => new RemoteFilterDefinition(),
FilterDefinition => new RemoteFilterDefinition(),
_ => throw new UnsupportedFilterDefinitionType(filterDefinition)
});
public void Add(IFilterDefinition filterElement)
{
if (Filters == null)
{
Filters = new List <IFilterDefinition>();
}
if (!Filters.Contains(filterElement))
{
Filters.Add(filterElement);
SetFilterMethod();
}
}
/// <inheritdoc/>
public Task <FilterValidationResult> Validate <TDefinition>(IFilterDefinition persistedDefinition, IFilterProcessor <TDefinition> filter, CancellationToken cancellationToken)
where TDefinition : IFilterDefinition
{
_logger.Trace("Finding validator for filter '{TargetStream}'", filter.Definition.TargetStream);
if (TryGetValidatorFor <TDefinition>(out var validator))
{
_logger.Trace("Validating filter '{TargetStream}'", filter.Definition.TargetStream);
return(validator.Validate(persistedDefinition, filter, cancellationToken));
}
return(Task.FromResult(new FilterValidationResult()));
}
/// <inheritdoc/>
public async Task <bool> TryPersist(ScopeId scopeId, IFilterDefinition filterDefinition, CancellationToken cancellationToken)
{
var tryGetStream = await _streamDefinitions.TryGet(scopeId, filterDefinition.TargetStream, cancellationToken).ConfigureAwait(false);
if (!tryGetStream.Success)
{
return(false);
}
var newStreamDefinition = new StreamDefinition(filterDefinition);
await _streamDefinitions.Persist(scopeId, newStreamDefinition, cancellationToken).ConfigureAwait(false);
return(true);
}
/// <inheritdoc/>
public FilterValidationResult DefinitionsAreEqual(IFilterDefinition persisted, IFilterDefinition registered)
{
if (persisted.Partitioned != registered.Partitioned)
{
return(FilterValidationResult.Failed($"The new stream generated from the filter will not match the old stream. {(persisted.Partitioned ? "The previous filter is partitioned while the new filter is not" : "The previous filter is not partitioned while the new filter is")}"));
}
if (persisted.Public != registered.Public)
{
return(FilterValidationResult.Failed($"The new stream generated from the filter will not match the old stream. {(persisted.Public ? "The previous filter is public while the new filter is not" : "The previous filter is not public while the new filter is")}"));
}
return(FilterValidationResult.Succeeded());
}
static bool EventsAreNotEqual(IFilterDefinition filterDefinition, StreamEvent newEvent, StreamEvent oldEvent, out FilterValidationResult failedResult)
{
failedResult = default;
if (newEvent.Event.EventLogSequenceNumber != oldEvent.Event.EventLogSequenceNumber)
{
failedResult = FilterValidationResult.Failed($"Event in new stream at position {newEvent.Position} is event {newEvent.Event.EventLogSequenceNumber} while the event in the old stream is event {oldEvent.Event.EventLogSequenceNumber}");
return(true);
}
if (filterDefinition.Partitioned && newEvent.Partition != oldEvent.Partition)
{
failedResult = FilterValidationResult.Failed($"Event in new stream at position {newEvent.Position} has is in partition {newEvent.Partition} while the event in the old stream is in partition {oldEvent.Partition}");
return(true);
}
return(false);
}
public void AddOrUpdateFilterDefinition(IFilterDefinition filterDefinition)
{
var definition = _filterDefinitions.FirstOrDefault(fd => fd.ColumnName == filterDefinition.ColumnName);
if (definition is null)
{
_filterDefinitions.Add(filterDefinition);
}
else
{
_filterDefinitions.Remove(definition);
_filterDefinitions.Add(filterDefinition);
}
OnFilterChanged?.Invoke(this, new FilterChangedEventArgs(_filterDefinitions));
}
public void AddOrUpdateFilterDefinition(IFilterDefinition filterDefinition, bool fireFilterChanged = true)
{
var definition = filterDefinitions.FirstOrDefault(fd => fd.ColumnName == filterDefinition.ColumnName);
if (definition is null)
{
filterDefinitions.Add(filterDefinition);
}
else
{
filterDefinitions.Remove(definition);
filterDefinitions.Add(filterDefinition);
}
if (fireFilterChanged)
{
OnFilterChanged?.Invoke(this, new FilterChangedEventArgs(filterDefinitions));
}
}
public static Expression ConvertToExpression <TParameter>(IFilterDefinition filter, ParameterExpression parameter)
where TParameter : class
{
var memberExpression = Expression.Property(parameter, filter.ColumnName);
var constantExpression = Expression.Constant(filter.Value);
switch (filter.FilterOperation)
{
case FilterOperation.Equal:
return(Expression.Equal(memberExpression, constantExpression));
case FilterOperation.GreaterThan:
return(Expression.GreaterThan(memberExpression, constantExpression));
case FilterOperation.GreaterThanOrEqual:
return(Expression.GreaterThanOrEqual(memberExpression, constantExpression));
case FilterOperation.LessThan:
return(Expression.LessThan(memberExpression, constantExpression));
case FilterOperation.LessThanOrEqual:
return(Expression.LessThanOrEqual(memberExpression, constantExpression));
case FilterOperation.NotEqual:
return(Expression.NotEqual(memberExpression, constantExpression));
case FilterOperation.Contains:
return(Expression.Call(memberExpression, ContainsMethod, constantExpression));
case FilterOperation.StartsWith:
return(Expression.Call(memberExpression, StartsWithMethod, constantExpression));
case FilterOperation.EndsWith:
return(Expression.Call(memberExpression, EndsWithMethod, constantExpression));
default:
throw new InvalidOperationException($"Conversion is not defined for operation {filter.FilterOperation}");
}
}
public void Add(IFilterDefinition definition)
{
filterDefinitions.Add(definition);
}
public void FluentBuilderExamples()
{
_myFilter = null; // TODO
_myAppender = Append.To.Console(c => c.Targeting.ConsoleOut());
_myLayout = Layout.Using.ExceptionMessage();
_myErrorHandler = Handle.Errors.OnlyOnce(h => h.PrefixedBy("ERROR"));
_myRenderer = null; // TODO
}
/// <inheritdoc/> public Task <FilterValidationResult> Validate(IFilterDefinition persistedDefinition, IFilterProcessor <PublicFilterDefinition> filter, CancellationToken cancellationToken) => _byComparingStreams.Validate(persistedDefinition, filter, cancellationToken);
public void Add(IFilterDefinition definition)
{
filterDefinitions.Add(definition);
}
/// <summary>
/// Configures the appender to use the specified filter definition.
/// </summary>
/// <param name="filter">An <see cref="IFilterDefinition"/> instance.</param>
/// <returns>The parent <typeparamref name="T"/> instance in the fluent API.</returns>
public T Filter(IFilterDefinition filter)
{
_filter = filter;
return(_parent);
}
/// <inheritdoc/> public Task <FilterValidationResult> Validate(IFilterDefinition persistedDefinition, IFilterProcessor <TypeFilterWithEventSourcePartitionDefinition> filter, CancellationToken cancellationToken) => _byComparingStreams.Validate(persistedDefinition, filter, cancellationToken);
public static Expression ConvertToExpression <TParameter>(IFilterDefinition filter, ParameterExpression parameter)
where TParameter : class
{
var memberExpression = Expression.Property(parameter, filter.ColumnName);
var constantExpression = Expression.Constant(filter.Value);
var stringComparisonExpression = Expression.Constant(filter.TextComparasion);
var valueType = filter.Value.GetType();
var condition = default(Expression);
switch (filter.FilterOperation)
{
case FilterOperation.Equal:
condition = valueType == typeof(string)
? Expression.Call(memberExpression, EqualsMethod, constantExpression, stringComparisonExpression)
: (Expression)Expression.Equal(memberExpression, constantExpression);
break;
case FilterOperation.GreaterThan:
condition = Expression.GreaterThan(memberExpression, constantExpression);
break;
case FilterOperation.GreaterThanOrEqual:
condition = Expression.GreaterThanOrEqual(memberExpression, constantExpression);
break;
case FilterOperation.LessThan:
condition = Expression.LessThan(memberExpression, constantExpression);
break;
case FilterOperation.LessThanOrEqual:
condition = Expression.LessThanOrEqual(memberExpression, constantExpression);
break;
case FilterOperation.NotEqual:
condition = valueType == typeof(string)
? Expression.Not(Expression.Call(memberExpression, EqualsMethod, constantExpression, stringComparisonExpression))
: (Expression)Expression.NotEqual(memberExpression, constantExpression);
break;
case FilterOperation.Contains:
condition = Expression.Call(memberExpression, ContainsMethod, constantExpression, stringComparisonExpression);
break;
case FilterOperation.StartsWith:
condition = Expression.Call(memberExpression, StartsWithMethod, constantExpression, stringComparisonExpression);
break;
case FilterOperation.EndsWith:
condition = Expression.Call(memberExpression, EndsWithMethod, constantExpression, stringComparisonExpression);
break;
default:
throw new InvalidOperationException($"Conversion is not defined for operation {filter.FilterOperation}");
}
if (!valueType.IsValueType)
{
var nullCheck = Expression.NotEqual(memberExpression, Expression.Constant(null, typeof(object)));
condition = Expression.AndAlso(nullCheck, condition);
}
return(condition);
}
/// <summary>
/// Initializes a new instance of the <see cref="UnsupportedFilterDefinitionType"/> class.
/// </summary>
/// <param name="filter">The unsupported filter.</param>
public UnsupportedFilterDefinitionType(IFilterDefinition filter)
: base($"IFilterDefinition implementation {filter.GetType()} is not supported.")
{
}
static bool FilterDefinitionHasBeenPersisted(Try <IFilterDefinition> tryGetFilterDefinition, out IFilterDefinition persistedDefinition, out FilterValidationResult validationResult)
{
if (!tryGetFilterDefinition.Success)
{
validationResult = tryGetFilterDefinition.Exception is StreamDefinitionDoesNotExist
? FilterValidationResult.Succeeded()
: FilterValidationResult.Failed(tryGetFilterDefinition.Exception.Message);
persistedDefinition = default;
return(false);
}
persistedDefinition = tryGetFilterDefinition.Result;
validationResult = default;
return(true);
}
static bool FilterDefinitionTypeHasChanged <TDefinition>(IFilterDefinition persistedDefinition, TDefinition registeredDefinition) => persistedDefinition.GetType() != registeredDefinition.GetType();
/// <summary>
/// Initializes a new instance of the <see cref="StreamDefinition"/> class.
/// </summary>
/// <param name="filterDefinition">The <see cref="IFilterDefinition" />.</param>
public StreamDefinition(IFilterDefinition filterDefinition)
{
FilterDefinition = filterDefinition;
}
