public void EventSourcingWithInlinieAggregation()
{
var store = TestDocumentStore.Create(optionsHandler: options =>
{
options.Events.AggregateStreamsInlineWith <Route>();
});
var routeId = CombGuidIdGeneration.New();
using (var session = store.OpenSession())
{
var route = new Route(routeId);
route.Plan(DateTime.Now.AddDays(1));
route.AddSource(new StopName("Home"), new TimeOfDay(17, 30), new Position(51.197894m, 4.481736m));
route.AddDestination(new StopName("WooRank"), new TimeOfDay(18, 30), new Position(50.828417m, 4.400963m));
route.AddStop(new StopName("Filling station"), new TimeOfDay(17, 45), new Position(50.828417m, 4.400963m));
route.Drive(new DateTime(2016, 05, 20, 17, 32, 0));
session.Events.StartStream <Route>(route.Id, route.GetChanges());
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var route = session.Load <Route>(routeId);
_testOutputHelper.WriteAsJson(route);
}
}
public void CreateAnInlineViewModelBasedOnDomainEvents()
{
var store = TestDocumentStore.Create();
var streamId = CombGuidIdGeneration.NewGuid();
using (var session = store.OpenSession())
{
session.Events.StartStream <Route>(streamId,
new RoutePlanned(streamId, DateTime.Now),
new StopCreated(Guid.NewGuid(), streamId, "Home", TestData.PositionHome),
new StopCreated(Guid.NewGuid(), streamId, "Visug", TestData.PositionVisug),
new StopCreated(Guid.NewGuid(), streamId, "Home", TestData.PositionHome)
);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var events = session.Events.FetchStream(streamId);
_testOutputHelper.WriteAsJson(events);
}
}
// TODO -- come back and do this with a single command!
public void ConfigureCommand(CommandBuilder builder)
{
var patchJson = _serializer.ToCleanJson(_patch);
var patchParam = builder.AddJsonParameter(patchJson);
var versionParam = builder.AddParameter(CombGuidIdGeneration.NewGuid(), NpgsqlDbType.Uuid);
builder.Append("update ");
builder.Append(_document.Table.QualifiedName);
builder.Append(" as d set data = ");
builder.Append(_transform.Identifier.QualifiedName);
builder.Append("(data, :");
builder.Append(patchParam.ParameterName);
builder.Append("), ");
builder.Append(DocumentMapping.LastModifiedColumn);
builder.Append(" = (now() at time zone 'utc'), ");
builder.Append(DocumentMapping.VersionColumn);
builder.Append(" = :");
builder.Append(versionParam.ParameterName);
if (!_fragment.Contains("where"))
{
builder.Append(" where ");
}
else
{
builder.Append(" ");
}
_fragment.Apply(builder);
applyUpdates(builder, _fragment);
}
public void EventSourcingShowTheEvents()
{
var store = TestDocumentStore.Create();
var routeId = CombGuidIdGeneration.New();
using (var session = store.OpenSession())
{
var route = new Route(routeId);
route.Plan(DateTime.Now.AddDays(1));
route.AddSource(new StopName("Home"), new TimeOfDay(17, 30), new Position(51.197894m, 4.481736m));
route.AddDestination(new StopName("WooRank"), new TimeOfDay(18, 30), new Position(50.828417m, 4.400963m));
route.AddStop(new StopName("Filling station"), new TimeOfDay(17, 45), new Position(50.828417m, 4.400963m));
route.Drive(new DateTime(2016, 05, 20, 17, 32, 0));
var events = route.GetChanges();
//_testOutputHelper.WriteAsJson(events);
session.Events.StartStream <Route>(route.Id);
session.Events.Append(route.Id, events);
session.SaveChanges();
}
using (var session = store.OpenSession())
{
var eventStream = session.Events.FetchStream(routeId);
_testOutputHelper.WriteAsJson(eventStream);
}
}
public Envelope CloneForSending(Envelope envelope)
{
if (envelope.Message == null)
{
throw new ArgumentNullException(nameof(envelope.Message), "Envelope.Message cannot be null");
}
var sending = envelope.Clone();
sending.Id = CombGuidIdGeneration.NewGuid();
sending.OriginalId = envelope.Id;
if (envelope.RequiresLocalReply)
{
sending.ReplyUri = envelope.ReplyUri ?? Channel.LocalReplyUri;
}
Channel.ApplyModifications(sending);
sending.ContentType = envelope.ContentType ?? ContentType;
sending.Writer = Writer;
sending.Destination = Destination;
sending.Route = this;
return(sending);
}
public void When_ids_are_generated_the_first_id_should_be_less_than_the_second()
{
var id1 = Format(CombGuidIdGeneration.NewGuid(new DateTime(2015, 03, 31, 21, 23, 00)));
var id2 = Format(CombGuidIdGeneration.NewGuid(new DateTime(2015, 03, 31, 21, 23, 01)));
id1.CompareTo(id2).ShouldBe(-1);
}
public Envelope CloneForSending(Envelope envelope)
{
if (envelope.Message == null && envelope.Data == null)
{
throw new ArgumentNullException(nameof(envelope.Message), "Envelope.Message cannot be null");
}
var writer = envelope.ContentType.IsEmpty()
? _writer
: _writers.ChooseWriter(envelope.ContentType);
var sending = envelope.CloneForWriter(writer);
sending.Id = CombGuidIdGeneration.NewGuid();
sending.CorrelationId = envelope.Id;
sending.ReplyUri = envelope.ReplyUri ?? _agent.ReplyUri;
sending.ContentType = _writer.ContentType;
sending.Destination = _agent.Destination;
sending.Sender = _agent;
applyEnvelopeRules(sending);
return(sending);
}
public EventStream AddEvents(IEnumerable <IEvent> events)
{
_events.AddRange(events);
_events.Where(x => x.Id == Guid.Empty).Each(x => x.Id = CombGuidIdGeneration.NewGuid());
return(this);
}
public EventStream(string stream, IEvent[] events, bool isNew)
{
Id = CombGuidIdGeneration.NewGuid();
Key = stream;
AddEvents(events);
IsNew = isNew;
}
public void RegisterUpdate(string tenantIdOverride, UpdateStyle updateStyle, UpdateBatch batch, object entity, string json)
{
var newVersion = CombGuidIdGeneration.NewGuid();
var currentVersion = batch.Versions.Version <T>(Identity(entity));
ICallback callback = null;
IExceptionTransform exceptionTransform = null;
var sprocName = determineDbObjectName(updateStyle, batch);
var tenantId = tenantIdOverride ?? batch.TenantId;
if (_mapping.UseOptimisticConcurrency && batch.Concurrency == ConcurrencyChecks.Enabled)
{
callback = new OptimisticConcurrencyCallback <T>(Identity(entity), batch.Versions, newVersion,
currentVersion);
}
if (!_mapping.UseOptimisticConcurrency && updateStyle == UpdateStyle.Update)
{
callback = new UpdateDocumentCallback <T>(Identity(entity));
}
if (updateStyle == UpdateStyle.Insert)
{
exceptionTransform = new InsertExceptionTransform <T>(Identity(entity), _mapping.Table.Name);
}
var call = batch.Sproc(sprocName, callback, exceptionTransform);
_sprocWriter(call, (T)entity, batch, _mapping, currentVersion, newVersion, tenantId);
}
public void EventSourcingWithInlineProjection()
{
var store = TestDocumentStore.Create(optionsHandler: options =>
{
options.Events.InlineProjections.Add(new RouteDetailsViewProjection());
});
var routeId = CombGuidIdGeneration.NewGuid();
using (var session = store.OpenSession())
{
var route = new Route(routeId);
route.Plan(DateTime.Now.AddDays(1));
route.AddSource(new StopName("Home"), new TimeOfDay(17, 30), new Position(51.197894m, 4.481736m));
route.AddDestination(new StopName("Visug"), new TimeOfDay(18, 30), new Position(50.828417m, 4.400963m));
route.AddStop(new StopName("Filling station"), new TimeOfDay(17, 45), new Position(50.828417m, 4.400963m));
route.Drive(new DateTime(2016, 05, 20, 17, 32, 0));
var events = route.GetChanges();
//_testOutputHelper.WriteAsJson(events);
session.Events.StartStream <Route>(route.Id);
session.Events.Append(route.Id, events);
session.SaveChanges();
}
//load the view by route id
using (var session = store.OpenSession())
{
var view = session.Load <RouteDetails>(routeId);
_testOutputHelper.WriteAsJson(view);
}
}
/// <summary>
/// Strictly for testing
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="@event"></param>
/// <returns></returns>
public EventStream Add <T>(T @event)
{
_events.Add(new Event <T>(@event)
{
Id = CombGuidIdGeneration.NewGuid()
});
return(this);
}
public void Can_Roundtrip_CombGuid_DateTimeOffset()
{
var timestamp = DateTimeOffset.UtcNow;
var comb = CombGuidIdGeneration.Create(Guid.NewGuid(), timestamp);
var roundtrip = CombGuidIdGeneration.GetTimestamp(comb);
roundtrip.ToUnixTimeMilliseconds().ShouldBe(timestamp.ToUnixTimeMilliseconds());
}
public static Guid GenerateNewGuid(bool standardGuid)
{
Guid resultGuid = standardGuid
? Guid.NewGuid()
: CombGuidIdGeneration.NewGuid();
return(resultGuid);
}
/// <summary>
/// Strictly for testing
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="@event"></param>
/// <returns></returns>
public StreamAction Add <T>(T @event)
{
_events.Add(new Event <T>(@event)
{
Id = CombGuidIdGeneration.NewGuid(),
StreamId = Id,
StreamKey = Key,
});
return(this);
}
public void AddParameters(IBatchCommand batch)
{
var patchJson = batch.Serializer.ToCleanJson(_patch);
var patchParam = batch.AddParameter(patchJson, NpgsqlDbType.Jsonb);
var versionParam = batch.AddParameter(CombGuidIdGeneration.NewGuid(), NpgsqlDbType.Uuid);
var where = _fragment.ToSql(batch.Command);
_sql = $@"
update {_document.Table.QualifiedName} as d
set data = {_transform.Function.QualifiedName}(data, :{patchParam.ParameterName}), {DocumentMapping.LastModifiedColumn} = (now() at time zone 'utc'), {DocumentMapping.VersionColumn} = :{versionParam.ParameterName}
where {where}";
}
public void generate_lots_of_guids()
{
var seed = Guid.NewGuid();
var list = new List <Guid>();
for (int i = 0; i < 20; i++)
{
list.Add(CombGuidIdGeneration.Create(seed, DateTime.UtcNow));
}
list.OrderBy(x => x).ShouldHaveTheSameElementsAs(list);
}
public void ConfigureCommand(CommandBuilder builder, IMartenSession session)
{
var patchParam = builder.AddJsonParameter(_serializer.ToCleanJson(_patch));
if (_patch.TryGetValue("value", out var document))
{
var value = PossiblyPolymorhpic ? _serializer.ToJsonWithTypes(document) : _serializer.ToJson(document);
var copy = new Dictionary <string, object>();
foreach (var item in _patch)
{
copy.Add(item.Key, item.Value);
}
copy["value"] = VALUE_LOOKUP;
var patchJson = _serializer.ToJson(copy);
var replacedValue = patchJson.Replace($"\"{VALUE_LOOKUP}\"", value);
patchParam = builder.AddJsonParameter(replacedValue);
}
var versionParam = builder.AddParameter(CombGuidIdGeneration.NewGuid(), NpgsqlDbType.Uuid);
builder.Append("update ");
builder.Append(_storage.TableName.QualifiedName);
builder.Append(" as d set data = ");
builder.Append(_transform.Identifier.QualifiedName);
builder.Append("(data, :");
builder.Append(patchParam.ParameterName);
builder.Append("), ");
builder.Append(SchemaConstants.LastModifiedColumn);
builder.Append(" = (now() at time zone 'utc'), ");
builder.Append(SchemaConstants.VersionColumn);
builder.Append(" = :");
builder.Append(versionParam.ParameterName);
if (!_fragment.Contains("where"))
{
builder.Append(" where ");
}
else
{
builder.Append(" ");
}
_fragment.Apply(builder);
applyUpdates(builder, _fragment);
}
public void Apply(CommandBuilder sql)
{
var version = CombGuidIdGeneration.NewGuid();
sql.Append("update ");
sql.Append(_mapping.Table.QualifiedName);
sql.Append(" as d set data = ");
sql.Append(_function.Identifier.QualifiedName);
sql.Append("(data), ");
sql.Append(DocumentMapping.LastModifiedColumn);
sql.Append(" = (now() at time zone 'utc'), ");
sql.Append(DocumentMapping.VersionColumn);
sql.Append(" = '");
sql.Append(version);
sql.Append("'");
}
private static void writeBasicSql(CommandBuilder sql, IDocumentMapping mapping, TransformFunction transform)
{
var version = CombGuidIdGeneration.NewGuid();
sql.Append("update ");
sql.Append(mapping.Table.QualifiedName);
sql.Append(" as d set data = ");
sql.Append(transform.Identifier.QualifiedName);
sql.Append("(data), ");
sql.Append(DocumentMapping.LastModifiedColumn);
sql.Append(" = (now() at time zone 'utc'), ");
sql.Append(DocumentMapping.VersionColumn);
sql.Append(" = '");
sql.Append(version);
sql.Append("'");
}
public void Apply(CommandBuilder sql)
{
var version = CombGuidIdGeneration.NewGuid();
sql.Append("update ");
sql.Append(_storage.TableName.QualifiedName);
sql.Append(" as d set data = ");
sql.Append(_function.Identifier.QualifiedName);
sql.Append("(data), ");
sql.Append(SchemaConstants.LastModifiedColumn);
sql.Append(" = (now() at time zone 'utc'), ");
sql.Append(SchemaConstants.VersionColumn);
sql.Append(" = '");
sql.Append(version.ToString());
sql.Append("'");
}
internal StreamAction AddEvents(IReadOnlyList <IEvent> events)
{
// TODO -- let's get rid of this maybe?
_events.AddRange(events);
foreach (var @event in events)
{
if (@event.Id == Guid.Empty)
{
@event.Id = CombGuidIdGeneration.NewGuid();
}
@event.StreamId = Id;
@event.StreamKey = Key;
}
return(this);
}
public StreamAction AddEvents(IEnumerable <object> events)
{
// TODO -- let's get rid of this maybe?
_events.AddRange(events.Select(coerce));
foreach (var @event in _events)
{
if (@event.Id == Guid.Empty)
{
@event.Id = CombGuidIdGeneration.NewGuid();
}
@event.StreamId = Id;
@event.StreamKey = Key;
}
return(this);
}
public void PrepareEvents(int currentVersion, EventGraph graph, Queue <long> sequences, IMartenSession session)
{
var timestamp = DateTimeOffset.UtcNow;
if (AggregateType != null)
{
AggregateTypeName = graph.AggregateAliasFor(AggregateType);
}
var i = currentVersion;
if (currentVersion != 0)
{
// Guard logic for optimistic concurrency
if (ExpectedVersionOnServer.HasValue)
{
if (currentVersion != ExpectedVersionOnServer.Value)
{
throw new EventStreamUnexpectedMaxEventIdException((object)Key ?? Id, AggregateType, ExpectedVersionOnServer.Value, currentVersion);
}
}
ExpectedVersionOnServer = currentVersion;
}
foreach (var @event in _events)
{
@event.Version = ++i;
@event.DotNetTypeName = graph.DotnetTypeNameFor(@event.EventType);
var mapping = graph.EventMappingFor(@event.EventType);
@event.EventTypeName = mapping.EventTypeName;
if (@event.Id == Guid.Empty)
{
@event.Id = CombGuidIdGeneration.NewGuid();
}
@event.Sequence = sequences.Dequeue();
@event.TenantId ??= session.Tenant.TenantId;
@event.Timestamp = timestamp;
}
Version = Events.Last().Version;
}
public void LoadAggregateById()
{
var slaveStore = TestDocumentStore.Create(ConnectionString.Slave,
optionsHandler: options =>
{
options.UpsertType = PostgresUpsertType.Legacy;
options.AutoCreateSchemaObjects = AutoCreate.None;
}, clear: false);
var masterStore = TestDocumentStore.Create(ConnectionString.Master, optionsHandler: options => options.UpsertType = PostgresUpsertType.Legacy);
var tempRouteId = CombGuidIdGeneration.New();
var routeId = CombGuidIdGeneration.New();
using (var massWriter = new Writer(masterStore))
using (var listenerMaster = new Listener("master", _testOutputHelper, masterStore, routeId, tempRouteId))
using (var listenerSlave = new Listener("slave", _testOutputHelper, slaveStore, routeId, tempRouteId))
using (var session = masterStore.OpenSession())
{
session.Store(new Route {
ID = tempRouteId
});
session.SaveChanges();
massWriter.Start();
Thread.Sleep(5000);
listenerSlave.Stored();
listenerMaster.Stored();
session.Store(new Route {
ID = routeId
});
session.SaveChanges();
listenerMaster.Start();
listenerSlave.Start();
_testOutputHelper.WriteLine($"Route stored");
Thread.Sleep(500);
}
}
public void load_non_existing_with_a_store_shoudl_return_new_added_document()
{
var routeId = CombGuidIdGeneration.NewGuid();
using (var session = theStore.OpenSession())
{
var details = session.Load <RouteDetails>(routeId);
details.ShouldBeNull();
var routeDetails = new RouteDetails {
Id = routeId
};
session.Store(routeDetails);
details = session.Load <RouteDetails>(routeId);
details.ShouldBeTheSameAs(routeDetails);
}
}
public void RegisterUpdate(UpdateBatch batch, object entity, string json)
{
var newVersion = CombGuidIdGeneration.NewGuid();
var currentVersion = batch.Versions.Version <T>(Identity(entity));
ICallback callback = null;
if (_mapping.UseOptimisticConcurrency)
{
callback = new OptimisticConcurrencyCallback <T>(Identity(entity), batch.Versions, newVersion, currentVersion);
}
var call = batch.Sproc(_upsertName, callback);
_sprocWriter(call, (T)entity, batch, _mapping, currentVersion, newVersion);
}
internal bool TryCreateTombstoneBatch(DocumentSessionBase session, out UpdateBatch batch)
{
if (session.UnitOfWork.Streams.Any())
{
var stream = StreamAction.ForTombstone();
var tombstone = new Tombstone();
var mapping = EventMappingFor <Tombstone>();
var operations = new List <IStorageOperation>();
var storage = session.EventStorage();
var dotNetTypeName = DotnetTypeNameFor(typeof(Tombstone));
operations.Add(_establishTombstone.Value);
var tombstones = session.UnitOfWork.Streams
.SelectMany(x => x.Events)
.Select(x => new Event <Tombstone>(tombstone)
{
Sequence = x.Sequence,
Version = x.Version,
TenantId = x.TenantId,
StreamId = EstablishTombstoneStream.StreamId,
StreamKey = EstablishTombstoneStream.StreamKey,
Id = CombGuidIdGeneration.NewGuid(),
EventTypeName = mapping.EventTypeName,
DotNetTypeName = dotNetTypeName
})
.Select(e => storage.AppendEvent(this, session, stream, e));
operations.AddRange(tombstones);
batch = new UpdateBatch(operations);
return(true);
}
batch = null;
return(false);
}
public Envelope CloneForSending(Envelope envelope)
{
if (envelope.Message == null && envelope.Data == null)
{
throw new ArgumentNullException(nameof(envelope.Message), "Envelope.Message cannot be null");
}
var sending = envelope.Clone();
sending.Id = CombGuidIdGeneration.NewGuid();
sending.CorrelationId = envelope.Id;
sending.Data = envelope.Data;
sending.ReplyUri = envelope.ReplyUri ?? Subscriber.ReplyUri;
sending.ContentType = envelope.ContentType ?? ContentType;
sending.Writer = Writer;
sending.Destination = Destination;
sending.Subscriber = Subscriber;
return(sending);
}
private void GenerateAndShowNewGuid()
{
Guid guid = GuidMaker.GenerateNewGuid(StandardGuidRadioButton.IsChecked.IsTrue());
GuidTextBox.Text = GuidMaker.FormatGuid(guid);
try
{
DateTimeOffset dateTimeOffset = CombGuidIdGeneration.GetTimestamp(guid);
if (dateTimeOffset.Date > new DateTime(1900, 1, 1) && dateTimeOffset.Date < new DateTime(2200, 1, 1))
{
CombGuidDateLabel.Content = dateTimeOffset.DateTime.ToString("O");
}
else
{
ShowNoCombGuid("Date of out range");
}
}
catch (Exception ex)
{
ShowNoCombGuid(ex.Message);
}
}
