public async Task RegisterPrimitiveEventInputAsync(PrimitiveEvent e)
{
Console.WriteLine(TAG + String.Format("Generated primitive event {0}.", e));
locallyGeneratedPrimitiveEventCount++;
internalEventQueue.Data.Enqueue(e);
}
public IQuery Registered(PrimitiveEvent primitiveEvent, Registered registered)
{
return(RawQuery.Create(@"
if exists
(
select null from Argument where Id = @Id
)
update
Argument
set
Name = @Name,
DataTypeName = @DataTypeName
where
Id = @Id
else
insert into Argument
(
Id,
Name,
DataTypeName
)
values
(
@Id,
@Name,
@DataTypeName
)
")
.AddParameterValue(Columns.Id, primitiveEvent.Id)
.AddParameterValue(Columns.Name, registered.Name)
.AddParameterValue(Columns.DataTypeName, registered.DataTypeName));
}
public void Save(PrimitiveEvent primitiveEvent)
{
_databaseGateway.ExecuteUsing(_queryFactory.SaveEvent(primitiveEvent));
if (primitiveEvent.IsSnapshot)
{
_databaseGateway.ExecuteUsing(_queryFactory.SaveSnapshot(primitiveEvent));
}
}
public IQuery SaveEvent(PrimitiveEvent primitiveEvent)
{
return(new RawQuery(_scriptProvider.Get("EventStore.Save"))
.AddParameterValue(EventStoreColumns.Id, primitiveEvent.Id)
.AddParameterValue(EventStoreColumns.DateRegistered, primitiveEvent.DateRegistered)
.AddParameterValue(EventStoreColumns.EventEnvelope, primitiveEvent.EventEnvelope)
.AddParameterValue(EventStoreColumns.EventType, primitiveEvent.EventType)
.AddParameterValue(EventStoreColumns.Version, primitiveEvent.Version)
.AddParameterValue(EventStoreColumns.IsSnapshot, primitiveEvent.IsSnapshot));
}
public IQuery Renamed(PrimitiveEvent primitiveEvent, Renamed renamed)
{
return(RawQuery.Create(@"
update
Argument
set
Name = @Name
where
Id = @Id
")
.AddParameterValue(Columns.Name, renamed.Name)
.AddParameterValue(Columns.Id, primitiveEvent.Id));
}
public void test_complexquery_duplicateimputprimitives_unequalIDs_Matches()
{
var inputs = new List <AbstractEvent>();
var sameAs = createPrimitiveEvents("AA");
var sameB = new PrimitiveEvent("B");
var sameC = new PrimitiveEvent("C");
var seqabinputs = new List <AbstractEvent>(sameAs);
seqabinputs.AddRange(createPrimitiveEvents("AB"));
seqabinputs.Add(sameB);
var seqabs = getOutputListFromInputList("[SEQ(A,B),[A,B],n(B)]", seqabinputs);
Assert.Equal(5, seqabs.Count); // 5x SEQ(A,B), only 2x with sameA and sameB should match later
inputs.AddRange(seqabs);
var seqacinputs = new List <AbstractEvent>(sameAs);
seqacinputs.AddRange(createPrimitiveEvents("AC"));
seqacinputs.Add(sameC);
var seqacs = getOutputListFromInputList("[SEQ(A,C),[A,C],n(B)]", seqacinputs);
Assert.Equal(5, seqacs.Count); // 5x SEQ(A,C), only 2x with sameA and sameC should match later
inputs.AddRange(seqacs);
var seqandbcdsinputs = new List <AbstractEvent>();
seqandbcdsinputs.AddRange(createPrimitiveEvents("C"));
seqandbcdsinputs.Add(sameC);
var seqbdinputs = new List <AbstractEvent>()
{
sameB
};
seqbdinputs.AddRange(createPrimitiveEvents("BDD"));
var seqbds = getOutputListFromInputList("[SEQ(B,D),[B,D],n(B)]", seqbdinputs);
Assert.Equal(4, seqbds.Count); // 4x SEQ(B,D), only 2x with sameB should match later
seqandbcdsinputs.AddRange(seqbds);
var seqandbcds = getOutputListFromInputList("[SEQ(AND(B,C), D),[SEQ(B,D),C],n(X)]", seqandbcdsinputs);
Assert.Equal(8, seqandbcds.Count); // 8x SEQ(AND(B,C), D), only 2x with sameC and sameB should match later
inputs.AddRange(seqandbcds);
var outputs = getOutputListFromInputList("[SEQ(A,AND(B,C),D),[SEQ(A,B),SEQ(A,C),SEQ(AND(B,C),D)],n(X))]", inputs);
Assert.Equal(4, outputs.Count);
}
public IQuery ValueRemoved(PrimitiveEvent primitiveEvent, ValueRemoved valueRemoved)
{
return(RawQuery.Create(@"
delete
from
ArgumentValue
where
ArgumentId = @Id
and
Value = @Value
")
.AddParameterValue(Columns.Id, primitiveEvent.Id)
.AddParameterValue(Columns.Value, valueRemoved.Value));
}
public IQuery ValueAdded(PrimitiveEvent primitiveEvent, ValueAdded valueAdded)
{
return(RawQuery.Create(@"
insert into ArgumentValue
(
ArgumentId,
Value
)
values
(
@Id,
@Value
)
")
.AddParameterValue(Columns.Id, primitiveEvent.Id)
.AddParameterValue(Columns.Value, valueAdded.Value));
}
public PrimitiveEvent[] generate()
{
// start timer, initialize and return empty list if the timer was not running
if (!stopwatch.IsRunning)
{
repopulateTimeArray();
return(new PrimitiveEvent[0]);
}
// count the random timestamps in the array that have passed and not yet been registered
var outputCount = 0;
double passedTime = stopwatch.Elapsed.TotalMilliseconds + elapsedTimeOffset;
while (timeArrayIndex < eventCount && timeArray[timeArrayIndex] <= passedTime)
{
outputCount++;
timeArrayIndex++;
}
// repopulate the array once the interval is over
if (passedTime - lastIntervalReset > intervalMS)
{
// count potentially remaining array timestamps before the array is reset
outputCount += eventCount - timeArrayIndex;
// calculate offset between upcoming actual interval change and theoretical interval change
// add this offset to the elapsed time afterwards, since the time between theoretical interval change
// and actual interval change would be lost otherwise
elapsedTimeOffset = passedTime - lastIntervalReset - intervalMS;
repopulateTimeArray();
}
// actually generate the output events
var outputs = new PrimitiveEvent[outputCount];
for (int i = 0; i < outputCount; i++)
{
outputs[i] = new PrimitiveEvent(eventName);
}
return(outputs);
}
public IQuery SaveSnapshot(PrimitiveEvent primitiveEvent)
{
return(new RawQuery(_scriptProvider.Get("SnapshotStore.Save"))
.AddParameterValue(EventStoreColumns.Id, primitiveEvent.Id)
.AddParameterValue(EventStoreColumns.Version, primitiveEvent.Version));
}
public void ValueRemoved(PrimitiveEvent primitiveEvent, ValueRemoved valueRemoved)
{
_databaseGateway.ExecuteUsing(_argumentQueryFactory.ValueRemoved(primitiveEvent, valueRemoved));
}
public ProjectionEvent(PrimitiveEvent primitiveEvent)
{
SequenceNumber = primitiveEvent.SequenceNumber;
PrimitiveEvent = primitiveEvent;
}
public void Removed(PrimitiveEvent primitiveEvent, Removed domainEvent)
{
_databaseGateway.ExecuteUsing(_queryFactory.Removed(primitiveEvent.Id, domainEvent));
}
public void PermissionAdded(PrimitiveEvent primitiveEvent, PermissionAdded domainEvent)
{
_databaseGateway.ExecuteUsing(_queryFactory.PermissionAdded(primitiveEvent.Id, domainEvent));
}
public void RegisterPrimitiveEventInputFork(PrimitiveEvent p_0) => node.RegisterPrimitiveEventInputAsync(p_0).Wait();
public Task RegisterPrimitiveEventInputAsync(PrimitiveEvent p_0) => node.RegisterPrimitiveEventInputAsync(p_0);
protected void registerPrimitiveEvent(PrimitiveEvent e)
{
e.knownToNodes.Add(this._nodeName);
proxyProvider.getProxy(_nodeName).RegisterPrimitiveEventInputFork(e);
}
public void Renamed(PrimitiveEvent primitiveEvent, Renamed renamed)
{
_databaseGateway.ExecuteUsing(_argumentQueryFactory.Renamed(primitiveEvent, renamed));
}
public IQuery Removed(PrimitiveEvent primitiveEvent, Removed removed)
{
return
(RawQuery.Create("delete from Argument where Id = @Id")
.AddParameterValue(Columns.Id, primitiveEvent.Id));
}
