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