public async Task CreateAsync_ShouldCreateUser()
{
// ARRANGE
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
var userStore = new DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole>(roleStore);
await userStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
var generalStore = userStore as IUserStore <DynamoIdentityUser>;
var user = new DynamoIdentityUser(TestUtils.RandomString(10));
// ACT
await generalStore.CreateAsync(user, CancellationToken.None);
// ASSERT
var retrievedUser = await dbProvider.Context.LoadAsync(user);
Assert.NotNull(retrievedUser);
Assert.Equal(user.UserName, retrievedUser.UserName);
Assert.Equal(user.NormalizedUserName, retrievedUser.NormalizedUserName);
}
}
public async Task DynamoRoleUsersStore_RemoveFromRole_RemovesUserFromRole()
{
var user = new DynamoIdentityUser(TestUtils.RandomString(10));
var roleName = TestUtils.RandomString(10);
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
await roleStore.AddToRoleAsync(user, roleName, CancellationToken.None);
var result = await roleStore.IsInRoleAsync(user, roleName, CancellationToken.None);
Assert.True(result);
// ACT
await roleStore.RemoveFromRoleAsync(user, roleName, CancellationToken.None);
// ASSERT
var result2 = await roleStore.IsInRoleAsync(user, roleName, CancellationToken.None);
Assert.False(result2);
}
}
public async Task DynamoRoleUsersStore_GetUserIdsInRole_GetsUsers()
{
var user1 = new DynamoIdentityUser(TestUtils.RandomString(10));
var user2 = new DynamoIdentityUser(TestUtils.RandomString(10));
var roleName = TestUtils.RandomString(10);
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
await roleStore.AddToRoleAsync(user1, roleName, CancellationToken.None);
Assert.True(await roleStore.IsInRoleAsync(user1, roleName, CancellationToken.None));
await roleStore.AddToRoleAsync(user2, roleName, CancellationToken.None);
Assert.True(await roleStore.IsInRoleAsync(user2, roleName, CancellationToken.None));
// ACT
var result = await roleStore.GetUserIdsInRoleAsync(roleName, CancellationToken.None);
// ASSERT
Assert.Contains(user1.Id, result);
Assert.Contains(user2.Id, result);
Assert.Equal(2, result.Count);
}
}
public async Task DynamoRoleUsersStore_AddToRole_HandlesDuplicateRoleUserEntry()
{
var user = new DynamoIdentityUser(TestUtils.RandomString(10));
var roleName = TestUtils.RandomString(10);
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
await roleStore.AddToRoleAsync(user, roleName, CancellationToken.None);
var result = await roleStore.IsInRoleAsync(user, roleName, CancellationToken.None);
Assert.True(result);
// ACT
await roleStore.AddToRoleAsync(user, roleName, CancellationToken.None);
// ASSERT
var roles = await roleStore.GetRolesAsync(user, CancellationToken.None);
Assert.Equal(1, roles.Count);
}
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new DynamoIdentityUser(model.Email, model.Email);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=532713
// Send an email with this link
//var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
//var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
//await _emailSender.SendEmailAsync(model.Email, "Confirm your account",
// "Please confirm your account by clicking this link: <a href=\"" + callbackUrl + "\">link</a>");
await _signInManager.SignInAsync(user, false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task DynamoIdentityUser_ShouldSaveAndRetrieveTheFutureOccuranceCorrectly()
{
var lockoutEndDate = new DateTime(2018, 2, 1, 0, 0, 0, DateTimeKind.Utc).AddTicks(8996910);
var user = new DynamoIdentityUser(TestUtils.RandomString(10));
user.LockUntil(lockoutEndDate);
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleUsers = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleUsers.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context, TestUtils.NewTableName());
var store = new DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole>(roleUsers);
await store.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context, TestUtils.NewTableName());
// ACT
var result = await store.CreateAsync(user, CancellationToken.None);
// ASSERT
Assert.True(result.Succeeded);
var retrievedUser = await dbProvider.Context.LoadAsync(user);
Assert.Equal(user.LockoutEndDate, retrievedUser.LockoutEndDate);
}
}
public async Task DynamoUserStore_ShouldPutThingsIntoUsersTableByDefault()
{
var user = new DynamoIdentityUser(TestUtils.RandomString(10));
using (var dbProvider = DynamoDbServerTestUtils.CreateDatabase())
{
var roleStore = new DynamoRoleUsersStore <DynamoIdentityRole, DynamoIdentityUser>();
await roleStore.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context, TestUtils.NewTableName());
var store = new DynamoUserStore <DynamoIdentityUser, DynamoIdentityRole>(roleStore);
await store.EnsureInitializedAsync(dbProvider.Client, dbProvider.Context);
// ACT
var result = await store.CreateAsync(user, CancellationToken.None);
// ASSERT
Assert.True(result.Succeeded);
var tableNames = (await dbProvider.Client.ListTablesAsync()).TableNames;
var tableExists = tableNames.Any(x => x.Equals("users", StringComparison.Ordinal));
Assert.True(tableExists);
}
}
public async Task <IActionResult> Register(RegisterViewModel model, string returnUrl = null)
{
ViewData["ReturnUrl"] = returnUrl;
if (ModelState.IsValid)
{
var user = new DynamoIdentityUser(model.Email, model.Email);
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _roleManager.AddToRoleAsync(user, "user", CancellationToken.None);
await _signInManager.SignInAsync(user, false);
_logger.LogInformation(3, "User created a new account with password.");
return(RedirectToLocal(returnUrl));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model,
string returnUrl = null)
{
if (ModelState.IsValid)
{
// Get the information about the user from the external login provider
var info = await _signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
return(View("ExternalLoginFailure"));
}
var user = new DynamoIdentityUser(model.Email, model.Email);
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
result = await _userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
_logger.LogInformation(6, "User created an account using {Name} provider.", info.LoginProvider);
// Update any authentication tokens as well
await _signInManager.UpdateExternalAuthenticationTokensAsync(info);
return(RedirectToLocal(returnUrl));
}
}
AddErrors(result);
}
ViewData["ReturnUrl"] = returnUrl;
return(View(model));
}
public async Task <IActionResult> AutoApprove(string emailToApprove)
{
var cancellationToken = GetCancellationToken();
var existingUser = await _userManager.FindByEmailAsync(emailToApprove);
if (existingUser != null)
{
ViewData["message"] = $"A user has already been registered with this email - perhaps another admin has already handled this request [{emailToApprove}]";
return(View());
}
var user = new DynamoIdentityUser(emailToApprove, emailToApprove);
var result = await _userManager.CreateAsync(user, Guid.NewGuid().ToString().ToUpper() + Guid.NewGuid().ToString().ToLower());
if (result.Succeeded)
{
await _roleManager.AddToRoleAsync(user, "user", CancellationToken.None);
_logger.LogInformation(3, "User created a new account with password.");
ViewData["message"] = $"User [{emailToApprove}] created and login email has been sent";
}
else
{
AddErrors(result);
ViewData["message"] = string.Join("<br />", result.Errors.Select(e => e.Description));
}
//set up the reset password link
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
var callbackUrl = Url.Action("ResetPassword", "Account", new { userId = user.Id, code = code }, protocol: HttpContext.Request.Scheme);
await _sesService.SendEmail(emailToApprove, GetRegistrationEmail(emailToApprove, callbackUrl), "Bryce Family Website Registration", cancellationToken);
return(View());
}
