private Expression <Func <TStoredEvent, bool> > AddObjectIdFilter(Expression <Func <TStoredEvent, bool> > result)
{
var criteria = default(Expression <Func <TStoredEvent, bool> >);
foreach (var filter in this.criteria.ObjectInstances)
{
var sourceType = typeNameConverter.Invoke(filter.ObjectType);
// Builds: TargetObject != null && TargetObject.ObjectId == id && TargetObject.ObjectType == type
var predicate = ((Expression <Func <TStoredEvent, bool> >)
(e => e.ObjectId != null && e.ObjectType == sourceType)).And
(EventObjectIdEquals(filter.ObjectId));
// ORs all object+id filters.
criteria = Or(criteria, predicate);
}
if (criteria == null)
{
return(result);
}
// AND the criteria built so far.
return(And(result, criteria));
}
/// <summary>
/// Converts a criteria object passed to the queryable event store
/// <see cref="IEventStore{TObjectId, TBaseEvent}.Query"/> method
/// into a Linq expression that can be used directly as a filter (<c>Where</c>)
/// over the stored queryable event stream.
/// </summary>
/// <typeparam name="TObjectId">The type of identifier used by domain objects in the domain.</typeparam>
/// <typeparam name="TBaseEvent">The base type or interface implemented by events in the domain.</typeparam>
/// <typeparam name="TStoredEvent">The type of the stored event.</typeparam>
/// <param name="store">The store to provide the query expression for.</param>
/// <param name="criteria">The criteria that will be converted to a Linq expression.</param>
/// <param name="typeNameConverter">The type name converter to use to transform the <see cref="Type"/>
/// filters in the criteria object into type name strings that are persisted by the store.</param>
public static Expression <Func <TStoredEvent, bool> > ToExpression <TObjectId, TBaseEvent, TStoredEvent>(
this IQueryableEventStore <TObjectId, TBaseEvent, TStoredEvent> store,
EventQueryCriteria <TObjectId> criteria,
Func <Type, string> typeNameConverter)
where TStoredEvent : class, IStoredEvent <TObjectId>
{
return(new CriteriaBuilder <TObjectId, TStoredEvent>(criteria, typeNameConverter).Build());
}
public IEnumerable <TBaseEvent> Query(EventQueryCriteria <TObjectId> criteria)
{
var expr = criteria.ToExpression(this, type => type.FullName);
var events = this.Events;
if (expr != null)
{
events = events.Where(expr);
}
return(events.Select(x => x.Event));
}
public IEnumerable <DomainEvent> Query(EventQueryCriteria <Guid> criteria)
{
// Both forms are available.
var expr2 = criteria.ToExpression(this, type => type.Name);
var expr = this.ToExpression(criteria, type => type.Name);
if (expr == null)
{
return(this.events.Select(x => x.Event));
}
return(this.events.AsQueryable().Where(expr).Select(x => x.Event));
}
/// <summary>
/// Queries the event store for events that match the given criteria.
/// </summary>
public virtual IEnumerable <TBaseEvent> Query(EventQueryCriteria <Guid> criteria)
{
var predicate = this.ToExpression(criteria, this.TypeNameConverter);
var events = this.Events.AsQueryable();
if (predicate != null)
{
events = events.Where(predicate).Cast <StoredEvent>();
}
return(events
.OrderBy(x => x.RowVersion)
// Executes the query against the database
.AsEnumerable()
// Dehydrates using the configured serializer.
.Select(x => this.Serializer.Deserialize <TBaseEvent>(x.Payload)));
}
private Expression <Func <TStoredEvent, bool> > AddEventFilter(Expression <Func <TStoredEvent, bool> > result)
{
var criteria = default(Expression <Func <TStoredEvent, bool> >);
foreach (var filter in this.criteria.EventTypes)
{
var sourceType = typeNameConverter.Invoke(filter);
// ORs all event filters.
criteria = Or(criteria, e => e.EventType == sourceType);
}
if (criteria == null)
{
return(result);
}
// AND the criteria built so far.
return(And(result, criteria));
}
public CriteriaBuilder(EventQueryCriteria <TObjectId> criteria, Func <Type, string> typeNameConverter)
{
this.criteria = criteria;
this.typeNameConverter = typeNameConverter;
}
public IEnumerable <TBaseEvent> Query(EventQueryCriteria <TObjectId> criteria)
{
return(this.Events.Where(this.ToExpression(criteria, type => type.FullName)).Select(x => x.Event));
}
public IEnumerable<DomainEvent> Query(EventQueryCriteria<Guid> criteria)
{
throw new NotImplementedException();
}
public IEnumerable <DomainEvent> Query(EventQueryCriteria <Guid> criteria)
{
throw new NotImplementedException();
}
