public Task <Unit> Handle(CreateSomeDataCommand request, CancellationToken cancellationToken) { try { using (var context = _dbContext) { var businessUser = _businessUserRepositoy.GetByApplicationUserId(request.ApplicationUserId, context); var someData = SomeAggregate.Create(request, businessUser.Id); _someDataWriteRepository.Create(someData, context); context.SaveChanges(); } _eventBus.Publish(new SomeDataCreatedEvent(request.Id, request.FirstName, request.MiddleName, request.LastName, request.Title, request.CreationDate)); return(Unit.Task); } catch (Exception e) { Console.WriteLine(e); throw; } }
public void SaveSomeDataShoulUpdateSomeDataInDatabaseAndSaveChanges() { var updateSomeDataCommand = BuildUpdateSomeDataCommand(); var businessUser = new BusinessUser { Id = Guid.NewGuid(), Gender = "SomeGender", Locale = "SomeLocale", Location = "SomeLocation", Identity = new ApplicationUser { Email = "*****@*****.**" } }; var someDataDb = SomeDataMapper.UpdateSomeDataCommandToPersistanceModel(updateSomeDataCommand); someDataDb.BusinessUserId = businessUser.Id; var someDataDbSet = new List <SomeData> { someDataDb }; var businessUserDb = new List <BusinessUser> { businessUser }; var businessUserMockSet = new MockDbSet <BusinessUser>(businessUserDb); var someDataMockSet = new MockDbSet <SomeData>(someDataDbSet); var contextMock = new Mock <SomeDataContext>(); contextMock.Setup(c => c.SomeData).Returns(someDataMockSet.Object); contextMock.Setup(c => c.BusinessUsers).Returns(businessUserMockSet.Object); var someDataRepository = new SomeDataWriteRepository(contextMock.Object); var updatedSomeData = SomeAggregate.Create(updateSomeDataCommand.SomeDataId, "NewFirstName", "NewMiddleName", "NewLastName", "NewTitle", new Color("#c1d0c3"), DateTime.Now, new FacebookUrl(null), Guid.NewGuid()); someDataRepository.Save(updatedSomeData); var updatedDb = someDataRepository.Get(updateSomeDataCommand.SomeDataId); contextMock.Verify(x => x.SaveChanges(), Times.Once); Assert.Equal(updatedDb.Id, updatedSomeData.Id); Assert.Equal(updatedDb.Color, updatedSomeData.Color); Assert.Equal(updatedDb.CreationDate, updatedSomeData.CreationDate); Assert.Equal(updatedDb.FacebookUrl, updatedSomeData.FacebookUrl); Assert.Equal(updatedDb.FirstName, updatedSomeData.FirstName); Assert.Equal(updatedDb.LastName, updatedSomeData.LastName); Assert.Equal(updatedDb.MiddleName, updatedSomeData.MiddleName); Assert.Equal(updatedDb.Title, updatedSomeData.Title); }
public void Delete(SomeAggregate someData, SomeDataContext dbContext) { var someDataToDelete = dbContext.SomeData.FirstOrDefault(d => d.Id == someData.Id); if (someDataToDelete != null) { dbContext.SomeData.Remove(someDataToDelete); } }
public SomeAggregate BuildSomeAggregate(SomeData someData) { return(SomeAggregate.Create(someData.Id, someData.FirstName, someData.MiddleName, someData.LastName, someData.Title, new Color(someData.Color), someData.CreationDate, new FacebookUrl(someData.FacebookUrl), someData.BusinessUserId)); }
public SomeAggregate BuildSomeAggregate(Guid someDataId) { return(SomeAggregate.Create(someDataId, firstName, middleName, lastName, title, new Color(color), creationDate, new FacebookUrl(facebookUrl), Guid.NewGuid())); }
public static SomeAggregate PersistanceModelToAggregateRoot(Data.Contexts.Models.SomeData persistanceModel) { return(SomeAggregate.Create( persistanceModel.Id, persistanceModel.FirstName, persistanceModel.MiddleName, persistanceModel.LastName, persistanceModel.Title, new Color(persistanceModel.Color), persistanceModel.CreationDate, new FacebookUrl(persistanceModel.FacebookUrl), persistanceModel.BusinessUserId)); }
public void FailsOnSequenceMismatch() { var someAggregate = new SomeAggregate(); var @eventWithTooLateSeqNumber = new SomeEvent("something"); // some global seq - not important @eventWithTooLateSeqNumber.Meta[DomainEvent.MetadataKeys.GlobalSequenceNumber] = 10.ToString(); // local seq that are too far ahead @eventWithTooLateSeqNumber.Meta[DomainEvent.MetadataKeys.SequenceNumber] = 1.ToString(); Assert.Throws <ApplicationException>(() => someAggregate.ApplyEvent(@eventWithTooLateSeqNumber, ReplayState.ReplayApply)); }
public static Data.Contexts.Models.SomeData SomeAggregateToPersistanceModel(SomeAggregate aggregate) { return(new Data.Contexts.Models.SomeData { Id = aggregate.Id, FirstName = aggregate.FirstName, MiddleName = aggregate.MiddleName, LastName = aggregate.LastName, Title = aggregate.Title, Color = aggregate.Color.Value, CreationDate = aggregate.CreationDate, FacebookUrl = aggregate.FacebookUrl.Value, BusinessUserId = aggregate.BusinessUserId }); }
public void AppliesEmittedEvents() { var aggregateRootRepository = CreateAggregateRootRepository(); var someAggregate = new SomeAggregate { UnitOfWork = new ConsoleOutUnitOfWork(aggregateRootRepository), }; someAggregate.Initialize("root_id"); someAggregate.DoSomething(); Assert.That(someAggregate.StuffThatWasDone.Count, Is.EqualTo(1)); Assert.That(someAggregate.StuffThatWasDone.First(), Is.EqualTo("emitted an event")); }
public void Save(SomeAggregate someData) { try { using (var context = SomeDataEntities) { Save(someData); context.SaveChanges(); } } catch (Exception e) { Console.WriteLine(e); throw; } }
public void Save(SomeAggregate someData, SomeDataContext dbContext) { var someDataToUpdate = dbContext.SomeData.FirstOrDefault(d => d.Id == someData.Id); if (someDataToUpdate == null) { return; } someDataToUpdate.Color = someData.Color.Value; someDataToUpdate.CreationDate = someData.CreationDate; someDataToUpdate.FacebookUrl = someData.FacebookUrl.Value; someDataToUpdate.FirstName = someData.FirstName; someDataToUpdate.LastName = someData.LastName; someDataToUpdate.MiddleName = someData.MiddleName; someDataToUpdate.Title = someData.Title; someDataToUpdate.BusinessUserId = someData.BusinessUserId; }
public void ProvidesSuitableMetadataOnEvents() { var timeForFirstEvent = new DateTime(1979, 3, 19, 19, 0, 0, DateTimeKind.Utc); var timeForNextEvent = timeForFirstEvent.AddMilliseconds(2); var aggregateRootRepository = CreateAggregateRootRepository(); var eventCollector = new InMemoryUnitOfWork(aggregateRootRepository, _defaultDomainTypeNameMapper); var someAggregate = new SomeAggregate { UnitOfWork = eventCollector, }; someAggregate.Initialize("root_id"); TimeMachine.FixCurrentTimeTo(timeForFirstEvent); someAggregate.DoSomething(); TimeMachine.FixCurrentTimeTo(timeForNextEvent); someAggregate.DoSomething(); var events = eventCollector.Cast <SomeEvent>().ToList(); var firstEvent = events[0]; Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.TimeUtc], Is.EqualTo(timeForFirstEvent.ToString("u"))); Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.Owner], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeAggregate, d60.Cirqus.Tests")); Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.Type], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeEvent, d60.Cirqus.Tests")); Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.SequenceNumber], Is.EqualTo("0")); Assert.That(firstEvent.Meta[DomainEvent.MetadataKeys.AggregateRootId], Is.EqualTo("root_id")); var nextEvent = events[1]; Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.TimeUtc], Is.EqualTo(timeForNextEvent.ToString("u"))); Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.Owner], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeAggregate, d60.Cirqus.Tests")); Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.Type], Is.EqualTo("d60.Cirqus.Tests.Aggregates.TestEventApplication+SomeEvent, d60.Cirqus.Tests")); Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.SequenceNumber], Is.EqualTo("1")); Assert.That(nextEvent.Meta[DomainEvent.MetadataKeys.AggregateRootId], Is.EqualTo("root_id")); }
public void Create(SomeAggregate someData, SomeDataContext dbContext) { var someDatatoSave = SomeDataMapper.SomeAggregateToPersistanceModel(someData); dbContext.SomeData.Add(someDatatoSave); }