Should_publish_AccountActivated_if_a_new_account_is_created_as_we_bypass_the_regular_account_registration_flow() { var invitation = new Invitation("*****@*****.**", "inviter"); var request = new AcceptInvitation("arne", "pass", invitation.InvitationKey) { AcceptedEmail = "*****@*****.**" }; invitation.Add(1, "arne"); _repository.GetByInvitationKeyAsync(request.InvitationKey).Returns(invitation); _accountRepository .WhenForAnyArgs(x => x.CreateAsync(null)) .Do(x => x.Arg <Account>().SetId(52)); var principal = PrincipalHelper.Create(52, "arne"); var actual = await _sut.AcceptInvitation(principal, request); await _messageBus.Received().SendAsync(principal, Arg.Any <AccountActivated>()); var evt = _messageBus.Method("SendAsync").Arg <AccountActivated>(); evt.AccountId.Should().Be(52); }
public async Task Should_create_an_Account_for_invites_to_new_users() { var invitation = new Invitation("*****@*****.**", "inviter"); var request = new AcceptInvitation("arne", "pass", invitation.InvitationKey) { AcceptedEmail = "*****@*****.**" }; invitation.Add(1, "arne"); _repository.GetByInvitationKeyAsync(request.InvitationKey).Returns(invitation); _accountRepository .WhenForAnyArgs(x => x.CreateAsync(null)) .Do(x => x.Arg <Account>().SetId(52)); var principal = PrincipalHelper.Create(52, "arne"); var actual = await _sut.AcceptInvitation(principal, request); await _accountRepository.Received().CreateAsync(Arg.Any <Account>()); var evt = _messageBus.Method("SendAsync").Arg <InvitationAccepted>(); evt.AccountId.Should().Be(52); }
private static void Main(string[] args) { var container = AutofacSetup.Build(); dispatcher = container.Resolve <CommandDispatcher>(); var lobbyId = Guid.NewGuid(); var gameId = Guid.NewGuid(); Console2.WriteLine("# Creating Game #", ConsoleColor.Red); var createLobby = new CreateLobby(lobbyId, gameId, "Test Game", Guid.NewGuid(), "Mat"); dispatcher.Dispatch(createLobby); Console.ReadLine(); Console2.WriteLine("# Inviting Richard #", ConsoleColor.Red); var invitationToken = Guid.NewGuid(); var playerId = Guid.NewGuid(); var invitePlayer = new InvitePlayer(lobbyId, playerId, "Richard", invitationToken); dispatcher.Dispatch(invitePlayer); Console.ReadLine(); Console2.WriteLine("# Accepting Invitation #", ConsoleColor.Red); var acceptInvitation = new AcceptInvitation(lobbyId, invitationToken); dispatcher.Dispatch(acceptInvitation); Console.ReadLine(); Console2.WriteLine("# Inviting Matt #", ConsoleColor.Red); var invitationToken2 = Guid.NewGuid(); var invitePlayer2 = new InvitePlayer(lobbyId, Guid.NewGuid(), "Matt", invitationToken2); dispatcher.Dispatch(invitePlayer2); Console.ReadLine(); Console2.WriteLine("# Accepting Invitation #", ConsoleColor.Red); var acceptInvitation2 = new AcceptInvitation(lobbyId, invitationToken2); dispatcher.Dispatch(acceptInvitation2); Console.ReadLine(); Console2.WriteLine("# Starting Game #", ConsoleColor.Red); var gameSetupId = Guid.NewGuid(); var startGame = new StartGame(lobbyId, gameSetupId); dispatcher.Dispatch(startGame); Console.ReadLine(); //var boardSetupId = new Guid("4c7e5f0fc0bf4d28a63ba9b0253bb9f1"); //var playerId = new Guid("59fbb53f-2c86-4b13-a6e5-740ffefdb2a7"); //var placeInfantryUnit = new PlaceInfantryUnit(boardSetupId, playerId, "Alaska"); //dispatcher.Dispatch(placeInfantryUnit); }
/// <summary> /// Accepts and deletes the invitation. Sends an event which is picked up by the application domain (which transforms /// the pending invite to a membership) /// </summary> /// <remarks> /// <para> /// Do note that an invitation can be accepted by using another email address than the one that the invitation was /// sent to. So take care /// when handling the <see cref="InvitationAccepted" /> event. Update the email that as used when sending the /// invitation. /// </para> /// </remarks> public async Task <ClaimsIdentity> AcceptInvitation(ClaimsPrincipal user, AcceptInvitation request) { var invitation = await _invitationRepository.GetByInvitationKeyAsync(request.InvitationKey); if (invitation == null) { _logger.Error("Failed to find invitation key" + request.InvitationKey); return(null); } await _invitationRepository.DeleteAsync(request.InvitationKey); Account account; if (request.AccountId == 0) { account = new Account(request.UserName, request.Password); account.SetVerifiedEmail(request.AcceptedEmail); account.Activate(); account.Login(request.Password); await _repository.CreateAsync(account); } else { account = await _repository.GetByIdAsync(request.AccountId); account.SetVerifiedEmail(request.AcceptedEmail); } var inviter = await _repository.FindByUserNameAsync(invitation.InvitedBy); ClaimsIdentity identity = null; identity = await CreateIdentity(account.Id, account.UserName, account.IsSysAdmin); // Account have not been created before the invitation was accepted. if (request.AccountId == 0) { await _messageBus.SendAsync(user, new AccountRegistered(account.Id, account.UserName)); await _messageBus.SendAsync(user, new AccountActivated(account.Id, account.UserName) { EmailAddress = account.Email }); } var e = new InvitationAccepted(account.Id, invitation.InvitedBy, account.UserName) { InvitedEmailAddress = invitation.EmailToInvitedUser, AcceptedEmailAddress = request.AcceptedEmail, ApplicationIds = invitation.Invitations.Select(x => x.ApplicationId).ToArray() }; await _messageBus.SendAsync(user, e); return(identity); }
public async Task should_ignore_invitations_where_the_key_is_not_registered_in_the_db() { var request = new AcceptInvitation(InvitedAccountId, "invalid") { AcceptedEmail = "*****@*****.**" }; var actual = await _sut.ExecuteAsync(request); actual.Should().BeNull(); }
public async Task Should_ignore_invitations_where_the_key_is_not_registered_in_the_db() { var request = new AcceptInvitation(InvitedAccountId, "invalid") { AcceptedEmail = "*****@*****.**" }; var principal = PrincipalHelper.Create(52, "arne"); var actual = await _sut.AcceptInvitation(principal, request); actual.Should().BeNull(); }
public async Task Should_ignore_invitations_where_the_key_is_not_registered_in_the_db() { var request = new AcceptInvitation(InvitedAccountId, "invalid") { AcceptedEmail = "*****@*****.**" }; _sut.Principal = PrincipalHelper.Create(52, "arne"); var actual = await _sut.ExecuteAsync(request); AssertionExtensions.Should((object)actual).BeNull(); }
public async Task should_delete_invitation_when_its_accepted_to_prevent_creating_multiple_accounts_with_the_same_invitation_key() { var invitation = new Invitation("*****@*****.**", "inviter"); var request = new AcceptInvitation(InvitedAccountId, invitation.InvitationKey) { AcceptedEmail = "*****@*****.**" }; invitation.Add(1, "arne"); _repository.GetByInvitationKeyAsync(request.InvitationKey).Returns(invitation); var actual = await _sut.ExecuteAsync(request); actual.Should().NotBeNull(); }
public async Task <ActionResult> Accept(AcceptViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var query = new GetInvitationByKey(model.InvitationKey); var invitation = await _queryBus.QueryAsync(query); if (invitation == null) { return(View("InvitationNotFound")); } var cmd = new AcceptInvitation(model.UserName, model.Password, model.InvitationKey) { AcceptedEmail = model.Email, FirstName = model.FirstName, LastName = model.LastName }; var reply = await _requestReplyBus.ExecuteAsync(cmd); if (reply == null) { ModelState.AddModelError("", "Failed to find an invitation with the specified key. You might have already accepted the invitation? If not, ask for a new one."); _logger.Error("Failed to find invitation " + model.InvitationKey); return(View(new AcceptViewModel())); } var getApps = new GetApplicationList { AccountId = reply.AccountId }; var apps = await _queryBus.QueryAsync(getApps); var identity = CreateIdentity(reply.AccountId, reply.UserName, false, apps); SignIn(identity); return(Redirect("~/#/account/accepted")); }
public async Task should_notify_system_of_the_accepted_invitation() { var invitation = new Invitation("*****@*****.**", "inviter"); var request = new AcceptInvitation(InvitedAccountId, invitation.InvitationKey) { AcceptedEmail = "*****@*****.**" }; invitation.Add(1, "arne"); _repository.GetByInvitationKeyAsync(request.InvitationKey).Returns(invitation); var actual = await _sut.ExecuteAsync(request); _eventBus.Received().PublishAsync(Arg.Any <InvitationAccepted>()); var evt = _eventBus.Method("PublishAsync").Arg <InvitationAccepted>(); evt.AcceptedEmailAddress.Should().Be(request.AcceptedEmail); evt.AccountId.Should().Be(InvitedAccountId); evt.ApplicationIds[0].Should().Be(1); evt.UserName.Should().Be(_invitedAccount.UserName); }
public async Task <ActionResult> Accept(AcceptViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var cmd = new AcceptInvitation(model.UserName, model.Password, model.InvitationKey) { AcceptedEmail = model.Email, FirstName = model.FirstName, LastName = model.LastName }; var identity = await _accountService.AcceptInvitation(this.ClaimsUser(), cmd); //TODO: Remove hack. // HERE since the message queue starts to process the events // before we are done with them. We need some way to stack up the publishing // until the current handler is done. // // can't use a message handler since we need a result from the invitation accept. // so that we can construct a new identity _uow.SaveChanges(); if (identity == null) { ModelState.AddModelError("", "Failed to find an invitation with the specified key. You might have already accepted the invitation? If not, ask for a new one."); _logger.Error("Failed to find invitation " + model.InvitationKey); return(View(new AcceptViewModel())); } await SignInAsync(identity); var url = Url.Content("~/"); return(RedirectToAction("UpdateSession", new { returnUrl = url })); }
public async Task should_publish_AccountRegistered_if_a_new_account_is_created_as_we_bypass_the_regular_account_registration_flow() { var invitation = new Invitation("*****@*****.**", "inviter"); var request = new AcceptInvitation("arne", "pass", invitation.InvitationKey) { AcceptedEmail = "*****@*****.**" }; invitation.Add(1, "arne"); _repository.GetByInvitationKeyAsync(request.InvitationKey).Returns(invitation); _accountRepository .WhenForAnyArgs(x => x.CreateAsync(null)) .Do(x => x.Arg <Account>().SetId(52)); await _sut.ExecuteAsync(request); _eventBus.Received().PublishAsync(Arg.Any <AccountRegistered>()); var evt = _eventBus.Method("PublishAsync").Arg <AccountRegistered>(); evt.AccountId.Should().Be(52); }
public async Task <ActionResult> Accept(AcceptViewModel model) { if (!ModelState.IsValid) { return(View(model)); } var cmd = new AcceptInvitation(model.UserName, model.Password, model.InvitationKey) { Email = model.Email, FirstName = model.FirstName, LastName = model.LastName }; var reply = await _requestReplyBus.ExecuteAsync(cmd); if (reply == null) { ModelState.AddModelError("", "Failed to find an invitation with the specified key. You might have already accepted the invitation? If not, ask for a new one."); _logger.Error("Failed to find invitation " + model.InvitationKey); return(View(new AcceptViewModel())); } FormsAuthentication.SetAuthCookie(reply.UserName, false); var user = new SessionUser(reply.AccountId, reply.UserName); SessionUser.Current = user; var getApps = new GetApplicationList(); var apps = await _queryBus.QueryAsync(getApps); SessionUser.Current.Applications = apps.ToDictionary(x => x.Id, x => x.Name); SessionUser.Current.Applications[0] = "Dashboard"; return(Redirect("~/#/account/accepted")); }
public async Task Should_notify_system_of_the_accepted_invitation() { var invitation = new Invitation("*****@*****.**", "inviter"); var request = new AcceptInvitation(InvitedAccountId, invitation.InvitationKey) { AcceptedEmail = "*****@*****.**" }; invitation.Add(1, "arne"); _repository.GetByInvitationKeyAsync(request.InvitationKey).Returns(invitation); var principal = PrincipalHelper.Create(52, "arne"); var actual = await _sut.AcceptInvitation(principal, request); await _messageBus.Received().SendAsync(principal, Arg.Any <InvitationAccepted>()); var evt = _messageBus.Method("SendAsync").Arg <InvitationAccepted>(); evt.AcceptedEmailAddress.Should().Be(request.AcceptedEmail); evt.AccountId.Should().Be(InvitedAccountId); evt.ApplicationIds[0].Should().Be(1); evt.UserName.Should().Be(_invitedAccount.UserName); }