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); }
/// <inheritdoc/> public Task <FilterValidationResult> Validate(IFilterDefinition persistedDefinition, IFilterProcessor <PublicFilterDefinition> filter, CancellationToken cancellationToken) => _byComparingStreams.Validate(persistedDefinition, filter, cancellationToken);
/// <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; }