public override async Task <IdentityResult> CreateAsync(ApplicationUser user, string password)
{
user.password = password;
await _store.CreateAsync(user);
return(new SuccessIdentityResult());
}
public async Task UserRoleStore_create_user_add_to_role()
{
var user = _userTestFactory.CreateUser();
var username = "******";
await _userStore.SetUserNameAsync(user, username, default(CancellationToken));
await _userStore.SetNormalizedUserNameAsync(user, username, default(CancellationToken));
await _userStore.CreateAsync(user, default(CancellationToken));
var foundUser = await _userStore.FindByIdAsync(user.Id, default(CancellationToken));
foundUser.UserName.ShouldMatch(user.UserName);
var role = _roleTestFactory.CreateRole();
await _roleStore.CreateAsync(role, default(CancellationToken));
await _roleStore.SetNormalizedRoleNameAsync(role, role.Name, default(CancellationToken));
await _userRoleStore.AddToRoleAsync(user, role.Name, default(CancellationToken));
var roles = await _userRoleStore.GetRolesAsync(user, default(CancellationToken));
roles.Count.ShouldBeGreaterThan(0);
var users = await _userRoleStore.GetUsersInRoleAsync(role.Name, default(CancellationToken));
users.Count.ShouldBeGreaterThan(0);
var firstUser = users.FirstOrDefault();
firstUser.ShouldNotBeNull();
firstUser.UserName.ShouldMatch(user.UserName);
}
public async Task UserStore_create_find_by_name()
{
var user = _userTestFactory.CreateUser();
var username = "******";
await _userStore.SetUserNameAsync(user, username, default(CancellationToken));
await _userStore.SetNormalizedUserNameAsync(user, username, default(CancellationToken));
await _userStore.CreateAsync(user, default(CancellationToken));
var foundUser = await _userStore.FindByNameAsync(user.UserName, default(CancellationToken));
foundUser.UserName.ShouldMatch(user.UserName);
}
public async Task <IActionResult> CreateAdmin(CreateAdminEditModel model)
{
if (ModelState.IsValid)
{
// Create the user
if (!await _userStore.UserExistsAsync(model.UserName))
{
var user = new User {
UserName = model.UserName, Name = model.Name, Email = model.Email
};
var result = await _userStore.CreateAsync(user, model.Password, "Administrator");
if (result.Success)
{
return(RedirectToAction("Login", "Account", new { area = "Admin" }));
}
ModelState.AddModelError(string.Empty, result.Error);
}
else
{
ModelState.AddModelError(string.Empty, "UserName is already taken.");
}
}
return(View(model));
}
public async Task <NameAnswer> SignUpAsync(string username, string password, uint role)
{
if (String.IsNullOrEmpty(username) || username.Length > 64)
{
return(new NameAnswer
{
Error = "Username value must be valid and less / equal 64 characters"
});
}
if (String.IsNullOrEmpty(password) || password.Length > 64 || password.Length < 8)
{
return(new NameAnswer
{
Error = "Password value must be valid and between 8 and 64 characters"
});
}
var user = await _userStore.GetAsync(username);
if (user != null)
{
return(new NameAnswer
{
Error = "User does exist!"
});
}
var salt = SecureWithSHA512(GetRandomSalt());
var combine = CombineWithSalt(username, password, salt);
var hash = SecureWithSHA512(combine);
user = new User
{
Name = username,
Salt = salt,
Password = hash,
RoleId = role
};
user = await _userStore.CreateAsync(user);
if (user == null)
{
return(new NameAnswer
{
Error = "User registration has failed"
});
}
return(new NameAnswer
{
Id = user.Id,
Name = user.Name
});
}
public async Task Create(T user, CancellationToken cancellationToken = default)
{
var foundUser = await _userStore.FindByNameAsync(user.UserName, cancellationToken);
if (foundUser != null)
{
return;
}
await _userStore.CreateAsync(user, cancellationToken);
}
public async Task CreateUserFIxture()
{
var expected = new ApplicationUser
{
UserName = "******",
PasswordHash = "abcdefhijklmnopqrstuvwxyz",
Claims = new List <IdentityUserClaim <int> >
{
new IdentityUserClaim <int> {
ClaimType = "TestClaimType1", ClaimValue = "TestClaimValue1"
},
new IdentityUserClaim <int> {
ClaimType = "TestClaimType2", ClaimValue = "TestClaimValue2"
}
}
};
var response = await userStore.CreateAsync(expected, System.Threading.CancellationToken.None);
Assert.IsTrue(response.Succeeded);
var actualByName = await userStore.FindByNameAsync(expected.UserName, System.Threading.CancellationToken.None);
Assert.IsNotNull(actualByName);
Assert.AreEqual(expected.UserName, actualByName.UserName);
Assert.AreEqual(expected.PasswordHash, actualByName.PasswordHash);
CollectionAssert.AreEqual(
expected.Claims.Select(iuc => (iuc.ClaimType, iuc.ClaimValue)).ToArray(),
actualByName.Claims.Select(iuc => (iuc.ClaimType, iuc.ClaimValue)).ToArray());
var actualById = await userStore.FindByIdAsync(actualByName.Id.ToString(), System.Threading.CancellationToken.None);
Assert.IsNotNull(actualById);
Assert.AreEqual(expected.UserName, actualById.UserName);
Assert.AreEqual(expected.PasswordHash, actualById.PasswordHash);
CollectionAssert.AreEqual(
expected.Claims.Select(iuc => (iuc.ClaimType, iuc.ClaimValue)).ToArray(),
actualById.Claims.Select(iuc => (iuc.ClaimType, iuc.ClaimValue)).ToArray());
await userStore.DeleteAsync(expected, System.Threading.CancellationToken.None);
}
public async Task <IActionResult> NewPreliminaryApplication([FromBody] PreliminaryApplicationDto applicationDto)
{
var user = await _users.FindByNameAsync(applicationDto.Email, new CancellationToken(false));
if (user != null)
{
return(BadRequest("Already pre-registered"));
}
var newUser = new IdentityUser()
{
Id = Guid.NewGuid().ToString(),
Email = applicationDto.Email,
UserName = applicationDto.Email,
NormalizedUserName = applicationDto.Email,
EmailConfirmed = false
};
newUser.PasswordHash = new PasswordHasher <IdentityUser>().HashPassword(newUser, RandomString(40));
var newCoreUser = CoreUser.Create(Guid.Parse(newUser.Id));
newCoreUser.Update(new CoreUserDto()
{
Access = AccessEnum.Standard,
Picture = @"data:image/png;base64,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"
});
_readWriteRepository.Create <CoreUser, Guid>(newCoreUser);
var application = Application.Create(Guid.Parse(newUser.Id), 1);
var preliminaryDto = new ApplicationDto()
{
UserId = Guid.Parse(newUser.Id),
Name = applicationDto.Name,
Status = StatusEnum.Preliminary,
DateOfBirth = applicationDto.DateOfBirth,
State = applicationDto.State,
Country = applicationDto.Country,
//Hold over variables
PhoneNo = application.PhoneNo,
RegistrationNo = application.RegistrationNo
};
application.Update(preliminaryDto);
_readWriteRepository.Create <Application, int>(application);
await _users.CreateAsync(newUser, default(CancellationToken));
return(Ok());
}
public async Task Create_User_many_Factor()
{
var testUser = CreateTestUser();
var createUserResult = await _userStore.CreateAsync(testUser, CancellationToken.None);
createUserResult.ShouldNotBeNull();
createUserResult.Succeeded.ShouldBeTrue();
int nCount = 10;
for (int i = 0; i < nCount; ++i)
{
var challengeFactor = CreateTestFactor();
var identityResult = await _multiFactorUserStore.AddToFactorAsync(
testUser, challengeFactor, CancellationToken.None);
identityResult.ShouldNotBeNull();
identityResult.Succeeded.ShouldBeTrue();
var findResult = await _multiFactorUserStore.FindByIdAsync(challengeFactor.FactorId,
CancellationToken.None);
findResult.ShouldNotBeNull();
findResult.FactorId.ShouldBe(challengeFactor.FactorId);
}
var factors = await _multiFactorUserStore.GetFactorsAsync(testUser, CancellationToken.None);
factors.ShouldNotBeNull();
factors.Count.ShouldBe(nCount);
foreach (var factor in factors)
{
factor.ShouldNotBeNull();
factor.Challenge.ShouldNotBeNull();
factor.ChallengeResponseHash.ShouldNotBeNull();
factor.FactorId.ShouldNotBeNull();
}
}
public async Task SeedAsync()
{
var cts = new CancellationTokenSource();
var role = new IdentityRole("Admin");
await mRoleStore.CreateAsync(role, cts.Token);
var user = new ApiUser {
Id = "mike", UserName = "******"
};
user.PasswordHash = mHasher.HashPassword(user, "123");
await mUserStore.CreateAsync(user, cts.Token);
}
public async Task CreateAsync_NewIdentityUser_ShouldPersistUserToDocument()
{
await _userStore.CreateAsync(new RavenIdentityUser()
{
UserName = "******", Email = "*****@*****.**"
});
using (var session = AsyncDocumentSession)
{
var user = (await session.Query <RavenIdentityUser>()
.SingleOrDefaultAsync(u => u.UserName == "user.one")
.ConfigureAwait(false));
Assert.IsNotNull(user);
}
}
public virtual async Task <IdentityResult> CreateAsync(TUser user)
{
// ThrowIfDisposed();
// await UpdateSecurityStampInternal(user);
// var result = await ValidateUserAsync(user);
// if (!result.Succeeded)
// {
// return result;
// }
// if (Options.Lockout.AllowedForNewUsers && SupportsUserLockout)
// {
// await GetUserLockoutStore().SetLockoutEnabledAsync(user, true, CancellationToken);
// }
// await UpdateNormalizedUserNameAsync(user);
// await UpdateNormalizedEmailAsync(user);
return(await Store.CreateAsync(user, CancellationToken));
}
public void CreateAsyncStoredProcExists()
{
try
{
var userModel = new UserModel()
{
Id = Guid.NewGuid().ToString(),
UserName = It.IsAny <string>(),
NormalizedUserName = It.IsAny <string>(),
PasswordHash = It.IsAny <string>(),
IsActive = true,
};
userStoreMethodLookup.CreateAsync(userModel, cancellationTokenSource.Token).Wait();
}
catch
{
Assert.Fail();
}
}
public void CreateAsync()
{
var userModel = new UserModel()
{
Id = Guid.NewGuid().ToString(),
UserName = It.IsAny <string>(),
NormalizedUserName = It.IsAny <string>(),
PasswordHash = It.IsAny <string>(),
IsActive = true,
};
var returnModel = new UserModel();
repository.Setup(x => x.GetData(It.IsAny <string>(), It.IsAny <CancellationToken>(), It.IsAny <(string, object)[]>())).ReturnsAsync(returnModel).Verifiable();
var task = userStore.CreateAsync(userModel, cancellationTokenSource.Token);
task.Wait();
Assert.IsTrue(task.Result.Succeeded);
repository.Verify();
repository.VerifyNoOtherCalls();
}
protected virtual async Task <AuthenticateResult> ProcessNewExternalAccountAsync(string provider, string providerId, IEnumerable <Claim> claims)
{
var user = await TryGetExistingUserFromExternalProviderClaimsAsync(provider, claims);
if (user == null)
{
user = await InstantiateNewUserFromExternalProviderAsync(provider, providerId, claims);
if (user == null)
{
throw new InvalidOperationException("CreateNewAccountFromExternalProvider returned null");
}
var createResult = await _userStore.CreateAsync(user);
if (!createResult.Succeeded)
{
return(new AuthenticateResult(createResult.Errors.First()));
}
}
var externalLogin = new ExternalLoginInfo(provider, providerId);
var addExternalResult = await _userStore.AddLoginAsync(user.Id, externalLogin);
if (!addExternalResult.Succeeded)
{
return(new AuthenticateResult(addExternalResult.Errors.First()));
}
var result = await AccountCreatedFromExternalProviderAsync(user.Id, provider, providerId, claims);
if (result != null)
{
return(result);
}
return(await SignInFromExternalProviderAsync(user.Id, provider));
}
public void Should_create_and_get_user()
{
//arrange
var user = new IdentityUser
{
Id = Guid.NewGuid(),
UserName = "******",
PasswordHash = "test_password",
Email = "*****@*****.**",
EmailConfirmed = true,
BirthDate = DateTimeOffset.Now,
City = "TestCity",
FirstName = "FirstNameTest",
SecondName = "SecondNameTest",
RegDate = DateTimeOffset.Now,
SecurityStamp = Guid.NewGuid()
};
//act
_userRepository.CreateAsync(user);
var result = _userRepository.FindByIdAsync(user.Id).Result;
//asserts
Assert.AreEqual(user.Id, result.Id);
Assert.AreEqual(user.UserName, result.UserName);
//Assert.AreEqual(user.PasswordHash, result.PasswordHash);
Assert.AreEqual(user.Email, result.Email);
Assert.AreEqual(user.EmailConfirmed, result.EmailConfirmed);
Assert.AreEqual(user.BirthDate, result.BirthDate);
Assert.AreEqual(user.City, result.City);
Assert.AreEqual(user.FirstName, result.FirstName);
Assert.AreEqual(user.SecondName, result.SecondName);
Assert.AreEqual(user.RegDate, result.RegDate);
Assert.AreEqual(user.SecurityStamp, result.SecurityStamp);
}
public async Task CreateAsync(User user)
{
await _userStore.CreateAsync(user);
}
private void GenerateData(IUserStore userStore)
{
CreateAsync(new Lot
{
Title = "HTC One M8 16GB Gunmetal Grey Unlocked",
Description = "An item that has been used previously",
StartTime = DateTime.Now,
EndTime = DateTime.Now.AddMonths(1),
StartPrice = new Currency("$125.66"),
Owner = userStore.CreateAsync(new User { Email = "*****@*****.**", Username = "******" }, "123456").Result
});
CreateAsync(new Lot
{
Title = "HTC One M9 32GB",
Description = "A brand-new, unused, unopened, undamaged item in its original packaging",
StartTime = DateTime.Now,
EndTime = DateTime.Now.AddMonths(1),
StartPrice = new Currency("$320.00"),
Owner = userStore.CreateAsync(new User { Email = "*****@*****.**", Username = "******" },"234567").Result
});
AddBid(_id, new Bid
{
User = userStore.CreateAsync(new User { Email = "*****@*****.**", Username = "******" },"345678").Result,
Amount = new Currency("$300.00"),
Timestamp = DateTime.Now.AddMinutes(1)
});
AddBid(_id, new Bid
{
User = userStore.CreateAsync(new User { Email = "*****@*****.**", Username = "******" }, "456789").Result,
Amount = new Currency("$320.00"),
Timestamp = DateTime.Now.AddMinutes(1)
});
}
public async Task Can_Perform_Operations_On_Users_And_Get_Preferences_From_Api()
{
// Arrange
var emailAddress = $"some.user.{Guid.NewGuid()}@some.domain.com";
var user = new LondonTravelUser()
{
CreatedAt = DateTime.UtcNow,
Email = emailAddress,
EmailNormalized = emailAddress,
GivenName = "Alexa",
Surname = "Amazon",
UserName = emailAddress,
UserNameNormalized = emailAddress,
};
string accessToken = Controllers.AlexaController.GenerateAccessToken();
string[] favoriteLines = new[] { "district", "northern" };
string userId;
using (IUserStore <LondonTravelUser> store = GetUserStore())
{
// Act
IdentityResult createResult = await store.CreateAsync(user, default);
// Assert
Assert.NotNull(createResult);
Assert.True(createResult.Succeeded);
Assert.NotEmpty(user.Id);
// Arrange
userId = user.Id;
// Act
LondonTravelUser actual = await store.FindByIdAsync(userId, default);
// Assert
Assert.NotNull(actual);
Assert.Equal(userId, actual.Id);
Assert.Null(actual.AlexaToken);
Assert.Equal(user.CreatedAt, actual.CreatedAt);
Assert.Equal(user.Email, actual.Email);
Assert.False(actual.EmailConfirmed);
Assert.NotEmpty(actual.ETag);
Assert.Equal(Array.Empty <string>(), actual.FavoriteLines);
Assert.Equal(user.GivenName, actual.GivenName);
Assert.Equal(Array.Empty <LondonTravelLoginInfo>(), actual.Logins);
Assert.Equal(user.Surname, actual.Surname);
Assert.Equal(user.UserName, actual.UserName);
// Arrange
string etag = actual.ETag;
actual.AlexaToken = accessToken;
actual.FavoriteLines = favoriteLines;
// Act
IdentityResult updateResult = await store.UpdateAsync(actual, default);
// Assert
Assert.NotNull(updateResult);
Assert.True(updateResult.Succeeded);
// Act
actual = await store.FindByNameAsync(emailAddress, default);
// Assert
Assert.NotNull(actual);
Assert.Equal(userId, actual.Id);
Assert.Equal(emailAddress, actual.Email);
Assert.NotEqual(etag, actual.ETag);
Assert.Equal(accessToken, actual.AlexaToken);
Assert.Equal(favoriteLines, actual.FavoriteLines);
}
// Arrange
using (var message = new HttpRequestMessage(HttpMethod.Get, "api/preferences"))
{
message.Headers.Authorization = new AuthenticationHeaderValue("bearer", accessToken);
using (var client = Fixture.CreateClient())
{
// Act
using (var response = await client.SendAsync(message, default))
{
// Assert
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);
string json = await response.Content.ReadAsStringAsync();
dynamic preferences = JObject.Parse(json);
Assert.Equal(userId, (string)preferences.userId);
Assert.Equal(favoriteLines, preferences.favoriteLines.ToObject <string[]>() as IList <string>);
}
}
}
// Arrange
using (IUserStore <LondonTravelUser> store = GetUserStore())
{
// Act
IdentityResult updateResult = await store.DeleteAsync(new LondonTravelUser()
{
Id = userId
}, default);
// Assert
Assert.NotNull(updateResult);
Assert.True(updateResult.Succeeded);
}
// Arrange
using (var message = new HttpRequestMessage(HttpMethod.Get, "api/preferences"))
{
message.Headers.Authorization = new AuthenticationHeaderValue("bearer", accessToken);
using (var client = Fixture.CreateClient())
{
// Act
using (var response = await client.SendAsync(message, default))
{
// Assert
Assert.Equal(HttpStatusCode.Unauthorized, response.StatusCode);
Assert.Equal("application/json", response.Content.Headers.ContentType.MediaType);
}
}
}
}
private static async Task CreateUser(IUserStore<IdentityUser, string> userStore, string id)
{
await Task.Run(async () => await userStore.CreateAsync(new IdentityUser
{
Id = id,
Email = CreateEmailFromId(id),
UserName = CreateNameFromId(id)
}));
}
public Task CreateUser(ApplicationUser user)
{
//создание юзера
return(_customUserStore.CreateAsync(user));
}
public Task ApplySeeds(User[] users)
{
return(Task.WhenAll(users.Select(user => _userStore.CreateAsync(user, CancellationToken.None))));
}
public Task <IdentityResult> CreateAsync(User user, CancellationToken cancellationToken)
{
return(_userStore.CreateAsync(user, cancellationToken));
}
