public UserRegisteredView(UserRegistered data) { if (data == null) { throw new ArgumentNullException(nameof(data)); } this.Data = data; }
private void Apply(UserRegistered @event) { try { Model.Add(new UserDisplayName(@event.UserId, $"{@event.LastName}, {@event.FirstName}")); } catch (Exception) { // read models don't throw } }
public void Given_a_register_user_should_raise_a_domain_event() { UserRegistered e = null; DomainEvents.Register((UserRegistered @event) => { e = @event; }); var user = User.Register("*****@*****.**", "qwerty", "Test", "User"); Assert.IsNotNull(e); Assert.IsNotNull(e.User.Id); }
void Apply(UserRegistered e) { Id = e.Id.ToString(); _username = e.Username; _email = e.Email; _phone = e.Phone; _hasedPassword = e.Password; _createdDate = e.RegisteredDate; _activeCode = e.ActiveCode; _websiteUrl = e.WebsiteUrl; }
private void HandleUserRegistered(UserRegistered userRegistered) { var user = GetUserModel(userRegistered); user.Id = (Guid)userRegistered.AggregateRootKey; user.Name = userRegistered.Name; user.Email = userRegistered.Email; //_userDao.Insert(_user); _sqlClient.Insertable(user).ExecuteCommand(); }
private void Handle(UserRegistered @event) { Id = @event.Subject; _state.Email = @event.Email; _state.FirstName = @event.FirstName; _state.LastName = @event.LastName; _state.UserToken = @event.ActivationToken; _state.LoggedIn = false; _state.IsVerified = false; Version = @event.Version; }
public IActionResult Post([FromBody] UserRegistration userRegistration) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } UserRegistered userRegistered = _userService.Register(userRegistration); // TODO: return Created return(Ok(userRegistered)); }
private void HandleUserRegistered(UserRegistered e) { var userModel = GetUserModel(e); userModel.Id = e.Id; userModel.Name = e.Name; userModel.Email = e.Email; _dbConnection.Execute("insert into user(Id, Name, Email) values(@id,@name, @email)", new { id = e.AggregateRootKey, name = e.Name, email = e.Email }); //_dbConnection.Set<DDD.Simple.Model.User>().Add(userModel); //this._dbContext.Entry<Model.User>(userModel).Reload(); //_dbContext.Add(userModel); }
private void HandleUserRegistered(UserRegistered e) { var userModel = GetUserModel(e); userModel.Id = e.Id; userModel.Name = e.Name; userModel.Email = e.Email; _dbContext.Set <Model.User>().Add(userModel); //_dbContext.Set<Model.OrderItem>().Add(new OrderItem { Id = Guid.NewGuid() }); //this._dbContext.Entry<Model.User>(userModel).Reload(); //_dbContext.Add(userModel); }
public async Task <IActionResult> Create([Bind("UserRegisteredId,Name,Surname,Email,PhoneNumber,DateOfBirth,Age")] UserRegistered userRegistered) { if (ModelState.IsValid) { userRegistered.UserRegisteredId = _userManager.GetUserId(HttpContext.User); _context.Add(userRegistered); await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Index))); } return(View(userRegistered)); }
private async Task Handle(UserRegistered @event, QueryModelStore queryModelStore) { // Get current instance of query model var queryModel = await queryModelStore.GetQueryModel <UserQueryModel>(@event.AggregateId, createIfMissing : true); // Set Query Model properties queryModel.FirstName = @event.FirstName; queryModel.LastName = @event.LastName; queryModel.DisplayName = @event.FirstName + " " + @event.LastName; // Create or Update Query model in Read Store (E.g. CosmosDB) await queryModelStore.SaveQueryModel(queryModel); }
public void GivenEmptyEventStore_WhenAddingEventsOneAtATime_ThenStoreShouldContainThoseEvents() { // Arrange IEventStore store = new InMemoryEventStore(); var userId = Guid.NewGuid(); var userRegistered = new UserRegistered(userId); // Act store.Update(userId, new[] { userRegistered }); // Assert CollectionAssert.IsNotEmpty(((InMemoryEventStore)store).Events); Assert.AreSame(userRegistered, ((InMemoryEventStore)store).Events.First()); }
public void GivenAnyEvent_WhenQueryingVersion_ThenShouldReturnCorrectVersion() { // Arrange var versionHandler = new RuntimeConfiguredVersionHandler(); versionHandler.AddConfiguration <UserRegistered>(e => e.Version, null); var evt = new UserRegistered(Guid.NewGuid()); // Act Guid version = versionHandler.GetVersion(evt); // Assert Assert.AreEqual(evt.Version, version); }
private void Apply(UserRegistered @event) { _email = @event.Email; _title = @event.Title; _firstname = @event.Firstname; _lastname = @event.Lastname; _phoneNumber = @event.PhoneNumber; _doB = @event.DoB; _loanReason = @event.LoanReason; _annualIncomeBeforeTax = @event.AnnualIncomeBeforeTax; _homeOwnership = @event.HomeOwnership; _monthlyMortgageContribution = @event.MonthlyMortgageContribution; _monthlyRentContribution = @event.MonthlyRentContribution; _employmentStatus = @event.EmploymentStatus; }
private async Task Handle(UserRegistered @event, Action acknowledgeEvent) { // Get current instance of query model var queryModel = await QueryById(@event.AggregateId) ?? QueryModel.CreateQueryModel <UserQueryModel>(@event.AggregateId); // Set Query Model properties queryModel.FirstName = @event.FirstName; queryModel.LastName = @event.LastName; queryModel.DisplayName = @event.FirstName + " " + @event.LastName; // Create or Update Query model in Read Store (E.g. CosmosDB) await QueryModelRepository.Save(queryModel); acknowledgeEvent(); }
public void GivenEmptyEventStore_WhenAddingEventsOneAtATime_ThenStoreShouldContainThoseEvents() { // Arrange IEventStore store = new InMemoryEventStore(new ConsoleLogger()); var userId = Guid.NewGuid(); var userRegistered = new UserRegistered(userId); // Act store.Save <User>(userId.ToString(), 0, new[] { userRegistered }); // Assert var allEvents = ((InMemoryEventStore)store).GetAllEvents(); CollectionAssert.IsNotEmpty(allEvents); Assert.AreSame(userRegistered, allEvents.First()); }
public void EventApply_Should_Arrive_To_The_LastState() { //---------Load & Replay Envents var userRegistered = new UserRegistered(1, "Admin", "John", "Doe"); var userActivated = new UserActivated(1); var user = new User(); user.Apply(userRegistered); user.Apply(userActivated); user.UserName.Should().Be("Admin"); user.FirstName.Should().Be("John"); user.LastName.Should().Be("Doe"); user.IsActive.Should().BeTrue(); }
public async Task <IActionResult> Register(LoginViewModel loginViewModel) { if (ModelState.IsValid) { var userExist = await _userManager.FindByNameAsync(loginViewModel.UserName); if (userExist != null) { ModelState.AddModelError("", "This user exist"); return(View(loginViewModel)); } var user = new IdentityUser() { UserName = loginViewModel.UserName }; var result = await _userManager.CreateAsync(user, loginViewModel.Password); if (result.Succeeded) { await Initializer.initial(_roleManager); if (loginViewModel.Lloji == 1) { await _userManager.AddToRoleAsync(user, "Admin"); } else { await _userManager.AddToRoleAsync(user, "UserMember"); var signInResult = await _signInManager.PasswordSignInAsync(user, loginViewModel.Password, false, false); UserRegistered userRegistered = new UserRegistered() { UserRegisteredId = loginViewModel.UserName, Email = loginViewModel.UserName }; _context.Add(userRegistered); await _context.SaveChangesAsync(); } return(RedirectToAction("Index", "Home")); } } return(View(loginViewModel)); }
public void GivenNewEvent_WhenSettingParentVersion_ThenShouldSetParentVersion() { // Arrange var userId = Guid.Parse("00000000-0000-0000-0000-000000000001"); var userRegisteredEvent = new UserRegistered(userId); var userChangedPasswordEvent = new UserChangedPassword("newpassword"); var versionHandler = new RuntimeConfiguredVersionHandler(); versionHandler.AddConfiguration <UserChangedPassword>(null, (e, v) => e.ParentVersion = v); // Act versionHandler.SetParentVersion(userChangedPasswordEvent, userRegisteredEvent.Version); // Assert Assert.AreEqual(userRegisteredEvent.Version, userChangedPasswordEvent.ParentVersion); }
public void It_should_serialize_then_deserialize_UserRegistered() { // Given var random = TestContext.CurrentContext.Random; var givenMessage = new UserRegistered( id: random.NextGuid(), email: random.GetString(), name: random.GetString()); // When var json = JsonConvert.SerializeObject(givenMessage); var deserializedMessage = JsonConvert.DeserializeObject <UserRegistered>(json); // Then Assert.That(deserializedMessage.Id, Is.EqualTo(givenMessage.Id)); Assert.That(deserializedMessage.Email, Is.EqualTo(givenMessage.Email)); Assert.That(deserializedMessage.Name, Is.EqualTo(givenMessage.Name)); }
protected override IEnumerable <CommandDefinition> GetCommand(object evt) { var command = evt switch { UserRegistered e => new UserRegisteredInsert(e) .CommandDefinition, EmailUpdated e => new CommandDefinition("update Accounts set Email=@Email where StreamId=@StreamId", e), PasswordUpdated e => new CommandDefinition("update Accounts set PasswordHash=@PasswordHash where StreamId=@StreamId", e), BioUpdated e => new CommandDefinition("update Accounts set Bio=@Bio where StreamId=@StreamId", e), ImageUpdated e => new CommandDefinition("update Accounts set Image=@Image where StreamId=@StreamId", e), UsernameUpdated e => new CommandDefinition("update Accounts set Username=@Username where StreamId=@StreamId", e), AccountFollowed e => new CommandDefinition("insert into Followers (FollowedUserId, FollowingUserId) values (@FollowedId, @StreamId)", e), AccountUnfollowed e => new CommandDefinition("delete from Followers where FollowedUserId=@UnfollowedId and FollowingUserId=@StreamId", e), _ => default }; return(ArrayOf(command)); }
static void Main(string[] args) { Console.WriteLine("Begin Console."); var container = new ResolverDependencies().Resolve(); DomainEvents.Container = new DomainEventsContainer(container); var user = new User("Francisco", "*****@*****.**"); var userRegistered = new UserRegistered(1, 2, user); DomainEvents.Raise(userRegistered); Console.WriteLine("End Console."); Console.ReadKey(); }
private static User ImmutableApply(User state, EventBase @event) { var alreadyRegistered = string.IsNullOrWhiteSpace(state.UserId); return(@event switch { NoopEvent _ => state, RoomAssigned _ => state, UserRegistered registered => alreadyRegistered ? state : new User { UserId = registered.UserId, FirstName = registered.FirstName, LastName = registered.LastName }, UserChangedName changedName => alreadyRegistered ? new User { UserId = changedName.UserId, FirstName = changedName.FirstName, LastName = changedName.LastName, TimesVoted = state.TimesVoted } : state, UserVoted voted => alreadyRegistered ? new User { UserId = state.UserId, FirstName = state.FirstName, LastName = state.LastName, TimesVoted = ++state.TimesVoted } : state, _ => state });
public void InvokingBehaviour_GivenSimpleAggregateRoot_ShouldRecordEvents() { // Arrange var user = new User(); user.Register(); // Act user.ChangePassword("newpassword"); IEnumerable <object> actual = user.GetUncommittedEvents(); var userRegisteredEvent = new UserRegistered(user.Id); var userChangedPasswordEvent = new UserChangedPassword("newpassword") { ParentVersion = userRegisteredEvent.Version }; IEnumerable <object> expected = new object[] { userRegisteredEvent, userChangedPasswordEvent }; // Assert CollectionAssertAreJsonEqual(expected, actual); }
protected override void OnCommand(object message) { switch (message) { case RegisterUserCommand { UserName: var userName } : Event e; if (this.userNames.Contains(userName)) { e = new UserAlreadyExists(userName); } else { e = new UserRegistered(userName); } Persist(e, Apply); Context.System.EventStream.Publish(e); break; }
private async Task HandleAsync(UserRegistered userRegistered) { User user = new User { Id = userRegistered.Id, FirstName = userRegistered.FirstName, LastName = userRegistered.LastName, PhoneNumber = userRegistered.PhoneNumber, EmailAddress = userRegistered.EmailAddress }; await repository.RegisterUserAsync(user); // Send Notification StringBuilder body = new StringBuilder(); body.AppendLine($"Dear {userRegistered.FirstName},\n"); body.AppendLine($"Put some nice welcome message here...\n"); await emailNotifier.SendEmailAsync( userRegistered.EmailAddress, "*****@*****.**", $"Welcome, {userRegistered.FirstName}", body.ToString()); }
public void GivenAggregateWithUncommittedEvents_WhenSaved_ThenBaseVersionShouldMatchCurrentVersion() { // Arrange var userId = Guid.NewGuid(); var eventStore = new InMemoryEventStore(); var userRegistered = new UserRegistered(userId); eventStore.Store(userId, userRegistered); var repository = new EventSourcingRepository <User>(eventStore, new Mock <IConcurrencyMonitor>().Object); var user = repository.Get(userId); user.ChangePassword("newpassword"); var currentVersion = user.GetUncommittedEvents().Cast <Event>().Last().Version; // Act repository.Save(user); // Assert Assert.AreEqual(currentVersion, user.BaseVersion, "User's base version has not been updated to match current version on successful save."); }
public async Task <IActionResult> Edit([Bind("UserRegisteredId,Name,Surname,Email,PhoneNumber,DateOfBirth,Age")] UserRegistered userRegistered) { if (ModelState.IsValid) { try { _context.Update(userRegistered); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!UserExists(userRegistered.UserRegisteredId)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Index))); } return(View(userRegistered)); }
public void can_change_name() { //given var user = (User)FormatterServices.GetUninitializedObject(typeof(User)); var userRegistered = new UserRegistered(Guid.NewGuid(), "mike", "Jones", "*****@*****.**"); ((IEventSource)user).Hydrate(new[] { userRegistered }); //when var firstName = "William"; var lastName = "Jones"; user.ChangeName(firstName, lastName); //then var events = ((IEventSource)user).TakeEvents(); Assert.Collection( events, (evt) => { var nameChanged = evt as NameChanged; Assert.NotNull(nameChanged); Assert.Equal(userRegistered.UserId, nameChanged.UserId); Assert.Equal(firstName, nameChanged.FirstName); Assert.Equal(lastName, nameChanged.LastName); }); }
public async Task multi_stream_projections_should_work() { // -------------------------------- // Create Groups // -------------------------------- // Regular Users // Admin Users // -------------------------------- var regularUsersGroupCreated = new UserGroupCreated(Guid.NewGuid(), "Regular Users"); theSession.Events.Append(regularUsersGroupCreated.GroupId, regularUsersGroupCreated); var adminUsersGroupCreated = new UserGroupCreated(Guid.NewGuid(), "Admin Users"); theSession.Events.Append(adminUsersGroupCreated.GroupId, adminUsersGroupCreated); await theSession.SaveChangesAsync(); // -------------------------------- // Create Users // -------------------------------- // Anna // John // Maggie // Alan // -------------------------------- var annaRegistered = new UserRegistered(Guid.NewGuid(), "Anna"); theSession.Events.Append(annaRegistered.UserId, annaRegistered); var johnRegistered = new UserRegistered(Guid.NewGuid(), "John"); theSession.Events.Append(johnRegistered.UserId, johnRegistered); var maggieRegistered = new UserRegistered(Guid.NewGuid(), "Maggie"); theSession.Events.Append(maggieRegistered.UserId, maggieRegistered); var alanRegistered = new UserRegistered(Guid.NewGuid(), "Alan"); theSession.Events.Append(alanRegistered.UserId, alanRegistered); await theSession.SaveChangesAsync(); // -------------------------------- // Assign users to Groups // -------------------------------- // Anna, Maggie => Admin // John, Alan => Regular // -------------------------------- var annaAndMaggieAssignedToAdminUsersGroup = new MultipleUsersAssignedToGroup(adminUsersGroupCreated.GroupId, new List <Guid> { annaRegistered.UserId, maggieRegistered.UserId }); theSession.Events.Append(annaAndMaggieAssignedToAdminUsersGroup.GroupId, annaAndMaggieAssignedToAdminUsersGroup); var johnAndAlanAssignedToRegularUsersGroup = new MultipleUsersAssignedToGroup(regularUsersGroupCreated.GroupId, new List <Guid> { johnRegistered.UserId, alanRegistered.UserId }); theSession.Events.Append(johnAndAlanAssignedToRegularUsersGroup.GroupId, johnAndAlanAssignedToRegularUsersGroup); await theSession.SaveChangesAsync(); // -------------------------------- // Check users' groups assignment // -------------------------------- // Anna, Maggie => Admin // John, Alan => Regular // -------------------------------- var annaGroupAssignment = await theSession.LoadAsync <UserGroupsAssignment>(annaRegistered.UserId); annaGroupAssignment.ShouldNotBeNull(); annaGroupAssignment.Id.ShouldBe(annaRegistered.UserId); annaGroupAssignment.Groups.ShouldHaveTheSameElementsAs(adminUsersGroupCreated.GroupId); var maggieGroupAssignment = await theSession.LoadAsync <UserGroupsAssignment>(maggieRegistered.UserId); maggieGroupAssignment.ShouldNotBeNull(); maggieGroupAssignment.Id.ShouldBe(maggieRegistered.UserId); maggieGroupAssignment.Groups.ShouldHaveTheSameElementsAs(adminUsersGroupCreated.GroupId); var johnGroupAssignment = await theSession.LoadAsync <UserGroupsAssignment>(johnRegistered.UserId); johnGroupAssignment.ShouldNotBeNull(); johnGroupAssignment.Id.ShouldBe(johnRegistered.UserId); johnGroupAssignment.Groups.ShouldHaveTheSameElementsAs(regularUsersGroupCreated.GroupId); var alanGroupAssignment = await theSession.LoadAsync <UserGroupsAssignment>(alanRegistered.UserId); alanGroupAssignment.ShouldNotBeNull(); alanGroupAssignment.Id.ShouldBe(alanRegistered.UserId); alanGroupAssignment.Groups.ShouldHaveTheSameElementsAs(regularUsersGroupCreated.GroupId); }