private void LoadCreattation(PersonCreated personCreated)
{
Id = personCreated.Id;
Email = personCreated.Email;
FirstName = personCreated.FirstName;
LastName = personCreated.LastName;
}
// Creating persons individually, not validating uniqueness through a list or anything
public void Create(
string personId,
string nfcId,
string lastname,
string firstname,
string displayName,
ContactInformation contactInformation,
string info,
DateTimeOffset timestamp)
{
// Never fails, as everything has been checked already
var e = new PersonCreated(
personId,
nfcId,
lastname,
firstname,
displayName,
contactInformation,
info)
{
Timestamp = timestamp
};
this.Apply(e);
}
/// <summary>
/// Applies the event. This method can be called when an aggregate method does RaiseEvent or
/// when the infrastructure loads the aggregate from the event stream.
/// </summary>
/// <param name="event">The @event.</param>
private void Apply(PersonCreated @event)
{
// in the apply event handlers we should only have property assignements
this.name = new PersonName(@event.Name);
this.currentAddress = new Address(@event.Street, @event.StreetNumber);
this.isAlive = true;
}
public static Person Create(string name, string family, string nationalCode, string motherName, string fatherName, string birthDate)
{
var person = new Person();
var createEvent = new PersonCreated(Guid.NewGuid().ToString(), name, family, motherName, fatherName, birthDate, nationalCode);
person.ApplyEvent(createEvent);
return(person);
}
public void ConventionRegisteredEvents_are_applied()
{
var person = AggregateFactory.BuildEmpty <ProgrammerAggregate>();
var personCreated = new PersonCreated(Guid.NewGuid().ToString(), Guid.NewGuid().ToString());
((IAggregate)person).Apply(personCreated);
Assert.Equal(personCreated.PersonId, person.PersonId);
}
public void When(PersonCreated e)
{
QueryModelRepository.LinkPeople.Add(new LinkPerson
{
PersonId = e.PersonId,
Name = e.Lastname + " " + e.Firstname,
Email = e.ContactInformation.Email,
Phone = e.ContactInformation.Phone
});
}
public void On(PersonCreated @event)
{
PersonId = Guid.Parse(@event.PersonId);
Name = @event.Name;
Family = @event.Family;
MotherName = @event.MotherName;
FatherName = @event.FatherName;
NationalCode = @event.NationalCode;
BirthDate = @event.BirthDate;
}
public void TestEventInfoCreation()
{
var id = Guid.Parse("A9516716-C3D7-40FE-9CC1-065D5111CBBA");
var evt1 = new PersonCreated("Didiet", 20);
var evtInfo = EventInfo <Guid, Person> .NewBuilder(evt1, id, 0).Build();
var evtInfo2 = evtInfo.CopyBuilder().Version(1).Event(new PersonNameChanged("Noor")).Build();
Assert.NotNull(evtInfo);
Assert.NotNull(evtInfo2);
}
// Helper to avoid having this mapping information in many places. Not pedant.
public Person(PersonCreated e)
{
PersonId = e.PersonId;
NfcId = e.NfcId;
Lastname = e.Lastname;
Firstname = e.Firstname;
Email = e.ContactInformation.Email;
DisplayName = e.DisplayName;
Phone = e.ContactInformation.Phone;
Twitter = e.ContactInformation.Twitter;
Info = e.Info;
}
private void btnSave_Click(object sender, EventArgs e)
{
//try to create a person instance
try
{
var person = new Person(txtFirstName.Text, txtLastName.Text, chkHasDriverLicence.Checked, txtEmail.Text);
PersonCreated?.Invoke(this, person);
}
catch (Exception exception) // will catch validation errors and display on messagebox
{
MessageBox.Show(exception.Message);
}
}
public IActionResult AddUser(string name)
{
var personCreated = new PersonCreated();
var nameChanged = new ChangeName {
Name = name
};
using (var session = this.database.GetDocumentStore().LightweightSession())
{
session.Events.StartStream <Person>(Guid.NewGuid(), personCreated, nameChanged);
session.SaveChanges();
}
return(Redirect("/home/index"));
}
public static void PersonCreated(
[ActivityTrigger] PersonCreated @event,
[CosmosDB("cqrs", "lists",
ConnectionStringSetting = "CosmosDbConnectionString",
PartitionKey = "partitionKey",
CollectionThroughput = 400,
CreateIfNotExists = true)] out dynamic model,
ILogger log)
{
model = new PersonListModel
{
Id = @event.AggregateId,
FullName = $"{@event.Surname}, {@event.GivenName}",
Version = @event.Version,
PartitionKey = PartitionKeyValue
};
}
public static void PersonCreated(
[ActivityTrigger] PersonCreated @event,
[CosmosDB("cqrs", "people-details",
ConnectionStringSetting = "CosmosDbConnectionString",
PartitionKey = "id",
CollectionThroughput = 400,
CreateIfNotExists = true)] out dynamic model,
ILogger log)
{
model = new PersonDetailsModel
{
Id = @event.AggregateId,
GivenName = @event.GivenName,
Surname = @event.Surname,
Dob = @event.Dob,
Gender = @event.Gender,
Version = @event.Version
};
}
public Person Get(int id)
{
var events = dataRepository.GetEventDatas(nameof(Person), id);
Person person = new Person();
List <IEvent> myevents = new List <IEvent>();
foreach (var item in events)
{
switch (item.EventType)
{
case nameof(PersonCreated):
PersonCreated personCreated = JsonConvert.DeserializeObject <PersonCreated>(item.EventSerialzedData);
myevents.Add(personCreated);
break;
case nameof(PersonEmailUpdate):
PersonEmailUpdate personEmailUpdate = JsonConvert.DeserializeObject <PersonEmailUpdate>(item.EventSerialzedData);
myevents.Add(personEmailUpdate);
break;
}
}
person.LoadFromEvents(myevents);
return(person);
}
public IEnumerable <NamedEventStream> LegacyDataAsEvents()
{
var happeningInventoryStream =
new NamedEventStream("HappeningsInventory-" + HappeningMessageHandler.RootAggregateId);
var happeningStreams = new List <NamedEventStream>();
var checkpointStreams = new List <NamedEventStream>();
var checkpoints = this.parser.Checkpoints;
var happeningsCreated = new Dictionary <string, DateTime>();
foreach (var h in this.parser.Happenings)
{
happeningsCreated.Add(h.Id, h.CreatedAt);
happeningInventoryStream.Events.Add(new HappeningInventoryItemCreated(h.Id, h.Default, h.CreatedAt.ToUtcOffset()));
var happeningStream = new NamedEventStream(CreateHappeningStreamId(h.Id));
happeningStreams.Add(happeningStream);
var happeningCreated = new HappeningCreated(h.Id)
{
Timestamp = h.CreatedAt.ToUtcOffset()
};
happeningStream.Events.Add(happeningCreated);
var checkpointListStream = new NamedEventStream("CheckpointList-" + h.Id);
checkpointStreams.Add(checkpointListStream);
var h1 = h;
foreach (var c in checkpoints.Where(m => m.HappeningId == h1.Id))
{
var validatedEvent = new CheckpointValidated(
h.Id,
c.Id.ToString(),
c.Order,
c.CheckpointType,
c.Name,
c.Location.Latitude,
c.Location.Longitude,
c.DistanceFromPreviousCheckpoint,
c.DistanceFromStart)
{
// Use timestamp little after the happening
Timestamp = h.CreatedAt.AddSeconds(1).ToUtcOffset()
};
checkpointListStream.Events.Add(validatedEvent);
var checkpointStream = new NamedEventStream(CreateCheckpointStreamId(c.Id));
checkpointStreams.Add(checkpointStream);
var createdEvent = new CheckpointCreated(
h.Id,
c.Id.ToString(),
c.CheckpointType,
c.Order,
c.Name,
c.Location.Latitude,
c.Location.Longitude,
c.DistanceFromPreviousCheckpoint,
c.DistanceFromStart)
{
// Use a timestamp that is little after validated event
Timestamp = validatedEvent.Timestamp.AddSeconds(1)
};
checkpointStream.Events.Add(createdEvent);
}
}
yield return(happeningInventoryStream);
int anonymousWalkers = 1;
var attendees = this.parser.Attendees.ToList();
var personIdMap = new Dictionary <Guid, string>();
foreach (var p in this.parser.People)
{
var personStream = new NamedEventStream("Person-" + p.Id);
string displayName = p.Name;
if (!p.MayShowNameToPublic)
{
displayName = string.Format(
CultureInfo.CurrentCulture, "Anonyymi kävelijä {0:n0}", anonymousWalkers);
anonymousWalkers++;
}
var namesplit = p.Name.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var lastname = namesplit[0];
var firstname = string.Join(" ", namesplit.Skip(1));
personIdMap.Add(p.Id, p.NewEventBasedId);
var personCreatedEvent = new PersonCreated(
p.NewEventBasedId,
null,
lastname,
firstname,
displayName,
new ContactInformation(p.Phone, p.Email, p.TwitterName),
null)
{
// Create all legacy persons immediately after first happening was created,
// as otherwise they would not been available on AttendeeScanIn etc. events.
Timestamp = happeningsCreated.Values.Min().AddSeconds(1).ToUtcOffset()
};
personStream.Events.Add(personCreatedEvent);
// Get attendance info for this person
personStream.Events.AddRange(
attendees.Where(m => m.PersonId == p.Id)
.Select(a =>
{
var linkEvent = new PersonLinkedToHappening(
a.Id.ToString(),
p.NewEventBasedId,
a.HappeningId,
null)
{
// Link immediately after happening has been created
Timestamp = happeningsCreated[a.HappeningId].AddSeconds(2).ToUtcOffset()
};
return(linkEvent);
}));
yield return(personStream);
}
var startedEmittedTo = new HashSet <string>();
foreach (var parsedReading in this.parser.Readings)
{
var reading = parsedReading.Entity;
var readingCheckpoint = checkpoints.First(m => m.Id == reading.CheckpointId);
var scanInfo = new ScanInfo(
readingCheckpoint.HappeningId,
reading.CheckpointId.ToString(),
personIdMap[attendees.First(m => m.Id == parsedReading.AttendeeId).PersonId],
"fooid",
reading.Timestamp.ToUtcOffset(),
reading.Timestamp.ToUtcOffset(),
reading.SavedBy);
var readingEvent = reading.ReadingType == ReadingType.In
? (AttendeeScanBase) new AttendeeScanIn(scanInfo)
: new AttendeeScanOut(scanInfo);
readingEvent.Id = reading.Id.ToString();
readingEvent.ScanId = readingEvent.Id;
// Find the correct checkpoint stream to append this reading event
var cpStream = checkpointStreams.First(m => m.Name.Equals(CreateCheckpointStreamId(reading.CheckpointId)));
cpStream.Events.Add(readingEvent);
if (readingCheckpoint.CheckpointType == CheckpointType.Start &&
startedEmittedTo.Add(readingCheckpoint.HappeningId))
{
// Emit happening started event
var happeningStartedEvent = new HappeningStarted(readingCheckpoint.HappeningId)
{
Timestamp = readingEvent.Timestamp.AddSeconds(1)
};
cpStream.Events.Add(happeningStartedEvent);
}
if (readingCheckpoint.CheckpointType == CheckpointType.Finish)
{
// Emit attendee completed event
var completedEvent = new AttendeeCompleted(
readingEvent.HappeningId,
readingEvent.PersonId)
{
Timestamp = readingEvent.Timestamp
};
cpStream.Events.Add(completedEvent);
}
}
foreach (var parsedQuitter in this.parser.Quitters)
{
var quit = parsedQuitter.Entity;
var scanInfo = new ScanInfo(
checkpoints.First(m => m.Id == quit.CheckpointId).HappeningId,
quit.CheckpointId.ToString(),
personIdMap[attendees.First(m => m.Id == parsedQuitter.AttendeeId).PersonId],
quit.Id.ToString(),
quit.Timestamp.ToUtcOffset(),
quit.Timestamp.ToUtcOffset(),
quit.SavedBy);
var quitEvent = new AttendeeQuit(
scanInfo,
quit.WalkedSinceLastCheckpoint,
quit.Description)
{
// Use the same ID as original data
Id = quit.Id.ToString()
};
// Find the correct stream to append this quit event
var s = happeningStreams.First(m => m.Name.Equals(CreateHappeningStreamId(scanInfo.HappeningId)));
s.Events.Add(quitEvent);
}
// Individual happening streams
foreach (var s in happeningStreams)
{
yield return(s);
}
foreach (var s in checkpointStreams)
{
yield return(s);
}
}
public void When(PersonCreated e) => UpdateContactInformation(e);
public void Apply(PersonCreated createdEvent)
{
UserName = createdEvent.UserName;
FirstName = createdEvent.FirstName;
LastName = createdEvent.LastName;
}
public virtual void OnPersonCreated()
{
CreateNotification(EventActionType.Created);
PersonCreated?.Invoke(this, new NewNotificationEventArgs(this));
}
private void Apply(PersonCreated @event)
{
Id = new PersonId(@event.Id);
Name = new Name(@event.FirstName, @event.LastName);
}
public void Apply(PersonCreated createdEvent)
{
Mapper.Map(createdEvent, this);
}
public void When(PersonCreated e) => PublishToContributorClients(e);
public async Task HandleMessageAsync(IKafkaMessage <string, CreatePerson> consumedMessage)
{
var jitter = new Random();
try
{
// Validation
ValidateMessage(consumedMessage);
// Add Idempotentcy Check -It's important to verify for possible duplicates of the same message
// Process
var serializedValue = JsonSerializer.Serialize(consumedMessage.Value);
_logger.LogInformation("Consumed message in service [key: '{key} '] [value: '{serializedValue}']", consumedMessage.Key, serializedValue);
foreach (var(key, value) in consumedMessage.Headers)
{
_logger.LogInformation("Header: {key}\tValue: {value}", key, value);
}
var personCreated = new PersonCreated()
{
Id = consumedMessage.Value.Id,
Address = consumedMessage.Value.Address,
DateOfBirth = consumedMessage.Value.DateOfBirth,
Name = consumedMessage.Value.Name,
Surname = consumedMessage.Value.Surname
};
var messageId = Guid.NewGuid().ToString();
var personCreatedMessage = new KafkaMessage <string, PersonCreated>
{
Key = personCreated.Id.ToString(),
Value = personCreated,
MessageId = messageId,
MessageType = nameof(PersonCreated)
};
var count = 1;
// Retry forever
var retryPolicy = Policy
.Handle <KafkaProducerException>()
.WaitAndRetryForeverAsync( // exponential back-off plus some jitter
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt > 6 ? 6 : retryAttempt))
+ TimeSpan.FromMilliseconds(jitter.Next(0, 100)),
(exception, timespan) =>
{
Console.Write($"RetryCount: {count} - Timespan: {timespan} - Exception: {exception.Message}");
count++;
});
// PublishEvent
await retryPolicy.ExecuteAsync(() => PublishEventAsync(personCreatedMessage));
}
catch (ValidationException ex)
{
// Add Handle for Poison Message
_logger.LogError(ex, ex.Message);
}
catch (Exception ex)
{
_logger.LogError(ex, ex.Message);
}
}
public void On(PersonCreated @event)
{
Id = @event.PersonId;
FirstName = @event.FirstName;
LastName = @event.LastName;
}
public void When(PersonCreated e)
{
QueryModelRepository.Dashboard.People.HandleCreate(e);
SortAttendeesByDisplayName();
}
public void When(PersonCreated e)
{
QueryModelRepository.EditPeople.HandleCreate(e);
}
public void HandleCreate(PersonCreated e) => Add(new Person(e));
private void Apply(PersonCreated @event)
{
Id = @event.Id;
}
