static void Main(string[] args)
{
ISupplierVisitor supplierVisitor = new SupplierVisitor();
IRecordCreator recordVisitor = new RecordCreator();
var farmer = new Farmer();
farmer.MoneyToPay = 1950;
farmer.Pay(supplierVisitor);
farmer.GenerateReport(recordVisitor);
Console.WriteLine($"Amount left to pay FARMER after calling Pay(): {farmer.MoneyToPay}");
var foreignSeller = new ForeignSeller();
foreignSeller.MoneyToPay = 50_000;
foreignSeller.Pay(supplierVisitor);
foreignSeller.GenerateReport(recordVisitor);
Console.WriteLine($"Amount left to pay FOREIGN SUPPLIER after calling Pay(): {foreignSeller.MoneyToPay}");
var cottageIndustrySeller = new CottageIndustrySupplier();
cottageIndustrySeller.MoneyToPay = 890;
cottageIndustrySeller.Pay(supplierVisitor);
cottageIndustrySeller.GenerateReport(recordVisitor);
Console.WriteLine($"Amount left to pay COTTAGE SUPPLIER after calling Pay(): {cottageIndustrySeller.MoneyToPay}");
Console.Read();
}
public void can_create_stream_write_record_for_single_event()
{
var record = RecordCreator.CreateStreamWriteRecordForSingleEvent(
timeStamp: _dateTime1,
correlationId: _guid1,
logPosition: _long1,
transactionPosition: _long2,
transactionOffset: _int1,
streamNumber: _long3,
startingEventNumber: _long4,
eventId: _guid2,
eventType: _string1,
eventData: _bytes3.Span,
eventMetadata: _bytes4.Span,
eventFlags: _prepareflags);
Assert.Equal(LogRecordType.StreamWrite, record.Header.Type);
Assert.Equal(LogRecordVersion.LogRecordV0, record.Header.Version);
Assert.Equal(_dateTime1, record.Header.TimeStamp);
Assert.Equal(_long1, record.Header.LogPosition);
Assert.Equal <Guid>(_guid1, record.SystemMetadata.CorrelationId);
Assert.Equal(_long2, record.SystemMetadata.TransactionPosition);
Assert.Equal(_int1, record.SystemMetadata.TransactionOffset);
Assert.Equal(0, record.WriteId.CategoryNumber);
Assert.Equal(0, record.WriteId.TopicNumber);
Assert.Equal(_long3, record.WriteId.StreamNumber);
Assert.Equal(_long4, record.WriteId.StartingEventNumber);
Assert.Equal <Guid>(_guid2, record.Event.SystemMetadata.EventId);
Assert.Equal(_string1, record.Event.SystemMetadata.EventType);
Assert.Equal(MemoryMarshal.ToEnumerable(_bytes3), MemoryMarshal.ToEnumerable(record.Event.Data));
Assert.Equal(MemoryMarshal.ToEnumerable(_bytes4), MemoryMarshal.ToEnumerable(record.Event.Metadata));
Assert.Equal(_prepareflags, record.Event.Header.Flags);
}
public PartitionTypeLogRecord(DateTime timeStamp, long logPosition, Guid partitionTypeId, Guid partitionId,
string name)
{
Record = RecordCreator.CreatePartitionTypeRecord(
timeStamp,
logPosition,
partitionTypeId,
partitionId,
name);
}
public PartitionLogRecord(DateTime timeStamp, long logPosition, Guid partitionId, Guid partitionTypeId,
Guid parentPartitionId, Raw.PartitionFlags flags, ushort referenceNumber, string name)
{
Record = RecordCreator.CreatePartitionRecord(
timeStamp,
logPosition,
partitionId,
partitionTypeId,
parentPartitionId,
flags,
referenceNumber,
name);
}
public LogV3StreamWriteRecord(
long logPosition,
long transactionPosition,
int transactionOffset,
Guid correlationId,
Guid eventId,
StreamId eventStreamId,
long expectedVersion,
DateTime timeStamp,
PrepareFlags flags,
string eventType,
ReadOnlySpan <byte> data,
ReadOnlySpan <byte> metadata)
{
Ensure.Nonnegative(logPosition, "logPosition");
Ensure.NotEmptyGuid(correlationId, "correlationId");
Ensure.NotEmptyGuid(eventId, "eventId");
Ensure.Nonnegative(transactionPosition, "transactionPosition");
if (transactionOffset < -1)
{
throw new ArgumentOutOfRangeException("transactionOffset");
}
if (eventStreamId < LogV3SystemStreams.FirstVirtualStream)
{
throw new ArgumentOutOfRangeException("eventStreamId", eventStreamId, null);
}
if (expectedVersion < Core.Data.ExpectedVersion.Any)
{
throw new ArgumentOutOfRangeException("expectedVersion");
}
eventType ??= "";
Record = RecordCreator.CreateStreamWriteRecordForSingleEvent(
timeStamp: timeStamp,
correlationId: correlationId,
logPosition: logPosition,
transactionPosition: transactionPosition,
transactionOffset: transactionOffset,
streamNumber: eventStreamId,
startingEventNumber: expectedVersion + 1,
eventId: eventId,
// temporarily storing the event type as the system metadata. later it will have a number.
eventType: eventType,
eventData: data,
eventMetadata: metadata,
// todo: translate
eventFlags: (Raw.EventFlags)flags);
}
public LogV3EpochLogRecord(
long logPosition,
DateTime timeStamp,
int epochNumber,
Guid epochId,
long prevEpochPosition,
Guid leaderInstanceId) : base()
{
Record = RecordCreator.CreateEpochRecord(
timeStamp: timeStamp,
logPosition: logPosition,
epochNumber: epochNumber,
epochId: epochId,
prevEpochPosition: prevEpochPosition,
leaderInstanceId: leaderInstanceId);
}
public void can_create_stream_type_record()
{
var record = RecordCreator.CreateStreamTypeRecord(
timeStamp: _dateTime1,
logPosition: _long1,
streamTypeId: _guid1,
partitionId: _guid2,
name: _string1);
Assert.Equal(LogRecordType.StreamType, record.Header.Type);
Assert.Equal(LogRecordVersion.LogRecordV0, record.Header.Version);
Assert.Equal(_dateTime1, record.Header.TimeStamp);
Assert.Equal(_guid1, record.Header.RecordId);
Assert.Equal(_long1, record.Header.LogPosition);
Assert.Equal(_guid2, record.SubHeader.PartitionId);
Assert.Equal(_string1, record.StringPayload);
}
public LogV3StreamRecord(
Guid streamId,
long logPosition,
DateTime timeStamp,
uint streamNumber,
string streamName,
Guid partitionId) : base()
{
Record = RecordCreator.CreateStreamRecord(
streamId: streamId,
timeStamp: timeStamp,
logPosition: logPosition,
streamNumber: streamNumber,
streamName: streamName,
partitionId: partitionId,
streamTypeId: Guid.Empty);
}
public void can_create_content_type_record()
{
var record = RecordCreator.CreateContentTypeRecord(
timeStamp: _dateTime1,
logPosition: _long1,
contentTypeId: _guid1,
partitionId: _guid2,
referenceNumber: _ushort1,
name: _string1);
Assert.Equal(LogRecordType.ContentType, record.Header.Type);
Assert.Equal(LogRecordVersion.LogRecordV0, record.Header.Version);
Assert.Equal(_dateTime1, record.Header.TimeStamp);
Assert.Equal(_guid1, record.Header.RecordId);
Assert.Equal(_long1, record.Header.LogPosition);
Assert.Equal(_guid2, record.SubHeader.PartitionId);
Assert.Equal(_ushort1, record.SubHeader.ReferenceNumber);
Assert.Equal(_string1, record.StringPayload);
}
public LogV3EventTypeRecord(
Guid eventTypeId,
Guid parentEventTypeId,
long logPosition,
DateTime timeStamp,
string eventType,
uint eventTypeNumber,
ushort eventTypeVersion,
Guid partitionId) : base()
{
Record = RecordCreator.CreateEventTypeRecord(
eventTypeId: eventTypeId,
parentEventTypeId: parentEventTypeId,
timeStamp: timeStamp,
logPosition: logPosition,
name: eventType,
eventTypeNumber: eventTypeNumber,
eventTypeVersion: eventTypeVersion,
partitionId: partitionId);
}
public void can_create_partition_record()
{
var record = RecordCreator.CreatePartitionRecord(
timeStamp: _dateTime1,
logPosition: _long1,
partitionId: _guid1,
partitionTypeId: _guid2,
parentPartitionId: _guid3,
flags: _byte1,
name: _string1);
Assert.Equal(LogRecordType.Partition, record.Header.Type);
Assert.Equal(LogRecordVersion.LogRecordV0, record.Header.Version);
Assert.Equal(_dateTime1, record.Header.TimeStamp);
Assert.Equal(_guid1, record.Header.RecordId);
Assert.Equal(_long1, record.Header.LogPosition);
Assert.Equal(_guid2, record.SubHeader.PartitionTypeId);
Assert.Equal(_guid3, record.SubHeader.ParentPartitionId);
Assert.Equal(_byte1, record.SubHeader.Flags);
Assert.Equal(_string1, record.StringPayload);
}
public void can_create_epoch()
{
var epochNumber = 5;
var record = RecordCreator.CreateEpochRecord(
timeStamp: _dateTime1,
logPosition: _long1,
epochNumber: epochNumber,
epochId: _guid1,
prevEpochPosition: _long2,
leaderInstanceId: _guid2);
Assert.Equal(LogRecordType.System, record.Header.Type);
Assert.Equal(LogRecordVersion.LogRecordV1, record.Header.Version);
Assert.Equal(_dateTime1, record.Header.TimeStamp);
Assert.Equal(_guid1, record.Header.RecordId);
Assert.Equal(_long1, record.Header.LogPosition);
Assert.Equal(epochNumber, record.SubHeader.EpochNumber);
Assert.Equal(_guid2, record.SubHeader.LeaderInstanceId);
Assert.Equal(_long2, record.SubHeader.PrevEpochPosition);
}
