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