public static List <Link> GetLinks(
UriBuilder uriBuilder,
string eventStreamName,
EventRange range,
int itemsOnCurrentPage)
{
var links = new List <Link>();
var currentPage = GetPageForItem(range.Start, range.Count);
uriBuilder.Path = $"{eventStreamName}/{range.Start},{range.End}";
links.Add(new Link(new[] { Link.Self }, uriBuilder.ToString()));
if (currentPage > 0)
{
uriBuilder.Path = $"{eventStreamName}/{range.Start - range.Count},{range.End - range.Count}";
links.Add(new Link(
new[] { Link.Previous },
uriBuilder.ToString()
));
}
if (NextPageExists(range.Count, itemsOnCurrentPage))
{
uriBuilder.Path = $"{eventStreamName}/{range.Start + range.Count},{range.End + range.Count}";
links.Add(new Link(
new[] { Link.Next },
uriBuilder.ToString()
));
}
return(links);
}
public void skip_event_sequence()
{
var range = new EventRange(new ShardName("name"), 0, 100)
{
Events = new List <IEvent>
{
new Event <AEvent>(new AEvent()),
new Event <AEvent>(new AEvent()),
new Event <AEvent>(new AEvent()),
new Event <AEvent>(new AEvent()),
new Event <AEvent>(new AEvent()),
}
};
var sequence = 111;
foreach (var @event in range.Events)
{
@event.Sequence = sequence++;
}
range.SkipEventSequence(114);
range.Events.Count.ShouldBe(4);
}
public async Task use_type_filters()
{
NumberOfStreams = 10;
await PublishSingleThreaded();
using var fetcher1 = new EventFetcher(theStore, theStore.Tenancy.Default.Database, new ISqlFragment[0]);
var shardName = new ShardName("name");
var range1 = new EventRange(shardName, 0, NumberOfEvents);
await fetcher1.Load(range1, CancellationToken.None);
var uniqueTypeCount = range1.Events.Select(x => x.EventType).Distinct()
.Count();
uniqueTypeCount.ShouldBe(5);
var filter = new EventTypeFilter(theStore.Events, new Type[] { typeof(Travel), typeof(Arrival) });
using var fetcher2 = new EventFetcher(theStore, theStore.Tenancy.Default.Database, new ISqlFragment[] { filter });
var range2 = new EventRange(shardName, 0, NumberOfEvents);
await fetcher2.Load(range2, CancellationToken.None);
range2.Events
.Select(x => x.EventType)
.OrderBy(x => x.Name).Distinct()
.ShouldHaveTheSameElementsAs(typeof(Arrival), typeof(Travel));
}
internal virtual EventRangeGroup GroupEvents(
DocumentStore store,
EventRange range,
CancellationToken cancellationToken)
{
_projection ??= Build(store);
return(new TenantedEventRange(store, _projection, range, cancellationToken));
}
public static TransportMessage GetTransportMessage(EventRange range)
{
List <DomainMessage> evts = Get(range);
var links = LinkBuilder.GetLinks(TransportMessageFactory.UriBuilder, StreamName, range, evts.Count);
return(new TransportMessage(
new TransportHeader(links),
evts
));
}
public async ValueTask <EventRangeGroup> GroupEvents(DocumentStore store, EventRange range, CancellationToken cancellationToken)
{
IReadOnlyList <TenantSliceGroup <TDoc, TId> > groups;
using (var session = store.QuerySession())
{
groups = await Slicer.SliceAsyncEvents(session, range.Events, store.Tenancy).ConfigureAwait(false);
}
return(new TenantSliceRange <TDoc, TId>(store, this, range, groups, cancellationToken));
}
public static List <EventStoreItem> GetEvents(
NpgsqlConnection dbConnection,
EventRange range)
{
var offset = range.Start;
var count = range.Count;
var queryResult = dbConnection.Query <EventStoreItem>(
SelectEventStoreRowsQuery,
new { offset, limit = count });
return(queryResult.ToList());
}
private static EventRange CreateEventRangeFromEvent(Event @event, ref int current_min)
{
var current_max = current_min + @event.ProbabilityWeight;
var eventRange = new EventRange
{
Min = current_min,
Max = current_max,
Event = @event
};
current_min = current_max + 1;
return(eventRange);
}
public void size_with_events()
{
var range = new EventRange("name", 0, 100)
{
Events = new List <IEvent>
{
new Event <AEvent>(new AEvent()),
new Event <AEvent>(new AEvent()),
new Event <AEvent>(new AEvent()),
new Event <AEvent>(new AEvent()),
new Event <AEvent>(new AEvent()),
}
};
range.Size.ShouldBe(5);
}
public static List <DomainMessage> Get(EventRange range)
{
int eventCount = Events.Count;
if ((range.Start + 1) > eventCount)
{
return(new List <DomainMessage>());
}
var count = range.End + 1 > eventCount
? eventCount - range.Start
: range.Count;
var subList = Events.GetRange((int)range.Start, (int)count);
return(subList);
}
public static TransportMessage GetTransportMessage(
NpgsqlConnection dbConnection,
EventRange range)
{
List <EventStoreItem> evts = GetEvents(dbConnection, range);
List <DomainMessage> domainMsgs = evts
.Select((x, i) => ToDomainEvent(x, range.Start + (long)i))
.ToList();
var headerLinks = LinkBuilder.GetLinks(
TransportMessageFactory.UriBuilder,
"eventstream/orderdomain/order",
range,
evts.Count);
return(new TransportMessage(
new TransportHeader(headerLinks),
domainMsgs
));
}
public async Task event_fetcher_simple_case()
{
using var fetcher = new EventFetcher(theStore, new ISqlFragment[0]);
NumberOfStreams = 10;
await PublishSingleThreaded();
var range1 = new EventRange(new ShardName("name"), 0, 10);
await fetcher.Load(range1, CancellationToken.None);
var range2 = new EventRange(new ShardName("name"), 10, 20);
await fetcher.Load(range2, CancellationToken.None);
var range3 = new EventRange(new ShardName("name"), 20, 38);
await fetcher.Load(range3, CancellationToken.None);
range1.Events.Count.ShouldBe(10);
range2.Events.Count.ShouldBe(10);
range3.Events.Count.ShouldBe(18);
}
public IEnumerable <EventsOverviewModel> CalendarEvents(EventRange range)
{
var db = UmbracoContext.Application.DatabaseContext.Database;
List <EventsOverviewModel> events = new List <EventsOverviewModel>();
if (range.id != 0)
{
events.AddRange(this.GetNormalEvents(range.id, range.culture ?? "en-us", range.start, range.end));
events.AddRange(this.GetRecurringEvents(range.id, range.culture ?? "en-us", range.start, range.end));
}
else
{
var calendar = db.Query <ECalendar>("SELECT * FROM ec_calendars").ToList();
foreach (var cal in calendar)
{
events.AddRange(this.GetNormalEvents(cal.Id, range.culture ?? "en-us", range.start, range.end));
events.AddRange(this.GetRecurringEvents(cal.Id, range.culture ?? "en-us", range.start, range.end));
}
}
return(events);
}
private void assertRangeWasEnqueued(long floor, long ceiling)
{
var range = new EventRange(new ShardName("the projection"), floor, ceiling);
_theAgent.Received().StartRange(range);
}
public InsertProjectionProgress(EventGraph events, EventRange progress)
{
_events = events;
_progress = progress;
}
public async ValueTask <IReadOnlyList <TenantSliceGroup <TDoc, TId> > > GroupEventRange(DocumentStore store,
IMartenDatabase database, EventRange range, CancellationToken cancellation)
{
await using var session = store.OpenSession(SessionOptions.ForDatabase(database));
return(await Slicer.SliceAsyncEvents(session, range.Events).ConfigureAwait(false));
}
internal static Command Completed(EventRange range)
{
return(new Command {
Range = range, Type = CommandType.RangeCompleted
});
}
public TenantSliceRange(EventRange range, IReadOnlyList <TenantSliceGroup <TDoc, TId> > groups)
{
Range = range;
Groups = groups;
}
public TenantSliceRange(DocumentStore store, AggregationRuntime <TDoc, TId> runtime, EventRange range,
IReadOnlyList <TenantSliceGroup <TDoc, TId> > groups, CancellationToken projectionCancellation) : base(range, projectionCancellation)
{
_store = store;
_runtime = runtime;
Groups = groups;
}
async ValueTask <EventRangeGroup> IAggregationRuntime.GroupEvents(DocumentStore store, IMartenDatabase database, EventRange range,
CancellationToken cancellationToken)
{
using var session = store.OpenSession(SessionOptions.ForDatabase(database));
var groups = await Slicer.SliceAsyncEvents(session, range.Events).ConfigureAwait(false);
return(new TenantSliceRange <TDoc, TId>(store, this, range, groups, cancellationToken));
}
public EventRangeGroup GroupEvents(DocumentStore store, EventRange range, CancellationToken cancellationToken)
{
var groups = Slicer.Slice(range.Events, store.Tenancy);
return(new TenantSliceRange <TDoc, TId>(store, this, range, groups, cancellationToken));
}
public UpdateProjectionProgress(EventGraph events, EventRange range)
{
Range = range;
_events = events;
}
public event_fetcher_tests()
{
theRange = new EventRange(theShardName, 0, 100);
}
protected override ValueTask <EventRangeGroup> groupEvents(DocumentStore store, IMartenDatabase daemonDatabase, EventRange range,
CancellationToken cancellationToken)
{
return(new ValueTask <EventRangeGroup>(new TenantedEventRangeGroup(store, daemonDatabase, _generatedProjection.Value, range, cancellationToken)));
}
protected override TenantSliceRange <TDoc, TId> applyGrouping(EventRange range)
{
var groups = _runtime.Slicer.Slice(range.Events, _tenancy);
return(new TenantSliceRange <TDoc, TId>(range, groups));
}
protected override ValueTask <EventRangeGroup> groupEvents(DocumentStore store, IMartenDatabase daemonDatabase, EventRange range,
CancellationToken cancellationToken)
{
_runtime ??= BuildRuntime(store);
return(_runtime.GroupEvents(store, daemonDatabase, range, cancellationToken));
}
public void size_with_no_events()
{
var range = new EventRange("name", 0, 100);
range.Size.ShouldBe(100);
}
public async ValueTask <EventRangeGroup> GroupEvents(DocumentStore store, IMartenDatabase database, EventRange range,
CancellationToken cancellationToken)
{
var groups = await GroupEventRange(store, database, range, cancellationToken).ConfigureAwait(false);
return(new TenantSliceRange <TDoc, TId>(store, this, range, groups, cancellationToken));
}
public TestEventRangeGroup(EventRange range) : base(range, CancellationToken.None)
{
}
public ValueTask <EventRangeGroup> GroupEvents(DocumentStore store, IMartenDatabase daemonDatabase, EventRange range,
CancellationToken cancellationToken)
{
return(new ValueTask <EventRangeGroup>(new TenantedEventRangeGroup(store, daemonDatabase, _projection, range, cancellationToken)));
}
