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