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; }