public async void ChangeUsername() { // Create user, then lookup by Id var originalUser = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(originalUser); CassandraUser foundUser = await UserManager.FindByIdAsync(originalUser.Id); // Change the username and update const string newUserName = "******"; foundUser.UserName = newUserName; IdentityResult result = await UserManager.UpdateAsync(foundUser); result.ShouldBeSuccess(); // Should not be able to find them by the old username foundUser = await UserManager.FindByNameAsync(originalUser.UserName); foundUser.Should().BeNull(); // Should still be able to find by id and new username foundUser = await UserManager.FindByIdAsync(originalUser.Id); foundUser.Should().NotBeNull(); foundUser.UserName.Should().Be(newUserName); foundUser = await UserManager.FindByNameAsync(newUserName); foundUser.Should().NotBeNull(); foundUser.Id.Should().Be(originalUser.Id); }
/// <summary> /// Creates a CassandraUser from a Row. If the Row is null, returns null. /// </summary> static CassandraUser ToCassandraUser(this Row row) { if (row == null) { return(null); } var user = new CassandraUser(row.GetValue <Guid>("userid"), row.GetValue <Guid>("tenantid"), row.GetValue <string>("username"), row.GetValue <string>("email")) { PasswordHash = row.GetValue <string>("password_hash"), SecurityStamp = row.GetValue <string>("security_stamp"), TwoFactorEnabled = row.GetValue <bool>("two_factor_enabled"), AccessFailedCount = row.GetValue <int>("access_failed_count"), LockoutEnabled = row.GetValue <bool>("lockout_enabled"), LockoutEndDate = row.GetValue <DateTimeOffset>("lockout_end_date"), PhoneNumber = row.GetValue <string>("phone_number"), PhoneNumberConfirmed = row.GetValue <bool>("phone_number_confirmed"), EmailConfirmed = row.GetValue <bool>("email_confirmed"), Created = row.GetValue <DateTimeOffset>("created"), Modified = row.IsNull("modified") ? new DateTimeOffset?() : row.GetValue <DateTimeOffset>("modified"), Enabled = row.GetValue <bool>("enabled"), Source = row.GetValue <string>("source"), SourceId = row.GetValue <string>("source_id") }; return(user); }
public async Task Test_Add_User_Find_by_email_Delete_User_Async() { var dao = Global.TenantDao; await dao.EstablishConnectionAsync(); List <CassandraUser> insertedUsers = new List <CassandraUser>(); int nCount = 1; for (int i = 0; i < nCount; ++i) { string userName = Guid.NewGuid().ToString(); var user = new CassandraUser() { Email = userName, UserName = userName, AccessFailedCount = 123, EmailConfirmed = true, Enabled = true, LockoutEnabled = true, PasswordHash = Guid.NewGuid().ToString(), PhoneNumber = Guid.NewGuid().ToString(), PhoneNumberConfirmed = true, SecurityStamp = Guid.NewGuid().ToString(), Source = Guid.NewGuid().ToString(), SourceId = Guid.NewGuid().ToString(), TwoFactorEnabled = true }; insertedUsers.Add(user); await dao.UpsertUserAsync(user); } foreach (var testUser in insertedUsers) { testUser.TenantId = dao.TenantId; var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email); Assert.IsNotNull(foundUserResult); var foundUserList = foundUserResult.ToList(); Assert.IsTrue(foundUserList.Any()); Assert.AreEqual(foundUserList.Count, 1); var foundUser = foundUserList[0]; Assert.IsTrue(CassandraUserComparer.ShallowComparer.Equals(foundUser, testUser)); } foreach (var testUser in insertedUsers) { await dao.DeleteUserAsync(testUser); var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email); Assert.IsNotNull(foundUserResult); var foundUserList = foundUserResult.ToList(); Assert.IsFalse(foundUserList.Any()); Assert.AreEqual(foundUserList.Count, 0); } }
public async void Authenticate() { // Create a user with a password var user = new CassandraUser(Guid.NewGuid()) {UserName = "******"}; await UserManager.CreateAsync(user, "somePassword"); // Should be able to authenticate user with password bool authenticated = await UserManager.CheckPasswordAsync(user, "somePassword"); authenticated.Should().BeTrue(); }
public async Task Test_add_user_modify_lockout_end_date_delete() { var dao = Global.TenantDao; await dao.EstablishConnectionAsync(); var guidId = Guid.NewGuid(); var userStore = new CassandraUserStore(); string userName = Guid.NewGuid().ToString(); var user = new CassandraUser() { Email = userName, UserName = userName, EmailConfirmed = false, PhoneNumberConfirmed = false, PhoneNumber = "310.383.1111", LockoutEnabled = false, PasswordHash = "1234", SecurityStamp = "1234", LockoutEndDate = DateTimeOffset.UtcNow }; await userStore.CreateAsync(user); var foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNotNull(foundUser); var lockOutDate = await userStore.GetLockoutEndDateAsync(foundUser); Assert.AreEqual(lockOutDate.Day, user.LockoutEndDate.Day); Assert.AreEqual(lockOutDate.Hour, user.LockoutEndDate.Hour); Assert.AreEqual(lockOutDate.Minute, user.LockoutEndDate.Minute); Assert.AreEqual(lockOutDate.Year, user.LockoutEndDate.Year); var future = user.LockoutEndDate.AddDays(5); await userStore.SetLockoutEndDateAsync(foundUser, future); await userStore.UpdateAsync(foundUser); foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNotNull(foundUser); lockOutDate = await userStore.GetLockoutEndDateAsync(foundUser); Assert.AreEqual(lockOutDate.Day, future.Day); Assert.AreEqual(lockOutDate.Hour, future.Hour); Assert.AreEqual(lockOutDate.Minute, future.Minute); Assert.AreEqual(lockOutDate.Year, future.Year); await userStore.DeleteAsync(foundUser); foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNull(foundUser); }
public async void FindByLogin() { // Create a user and add a login to the user var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); var login = new UserLoginInfo("facebook", Guid.NewGuid().ToString()); await UserManager.AddLoginAsync(user.Id, login); // Now we should be able to find the user by that login info CassandraUser foundUser = await UserManager.FindAsync(login); foundUser.ShouldBeEquivalentToUser(user); }
public static void Menu(string e, MongoUser m, NeoUser n, CassandraUser c) { Console.WriteLine("Do you want to:\n 1 Find new friend \n " + "2-Write a post\n" + "3-Look over s-bodies post\n" + "4-Go out"); var x = Console.ReadLine(); switch (x) { case "1": Console.WriteLine("Write FirstName of searched person "); string FN = Console.ReadLine(); Console.WriteLine("Write LastName"); string LN = Console.ReadLine(); if (n.Relationship == true) { Console.WriteLine("There is relationship"); } else { Console.WriteLine("There is not relationship"); } Console.WriteLine("The lenght is", n.PathBetweenID(e, LN)); m.ToFollow(FN, LN, e); n.Follow(e, LN); Menu(e, m, n, c); break; case "2": ISession session; c.NewPost(session); break; case "3": Console.WriteLine("Write FirstName of searched person "); N = Console.ReadLine(); Console.WriteLine("Write LastName"); S = Console.ReadLine(); m.PostReaction(N, S, e); Menu(e, m, n); break; case "4": Console.WriteLine("Bye:("); Thread.Sleep(1000); System.Environment.Exit(20); break; } }
static void Main(string[] args) { CassandraUser cu = new CassandraUser(); Console.WriteLine("Hello,sweety,enter your email,please!"); var em = Console.ReadLine(); cu.Login(em); cu.ReadAllPosts(); Menu(em, cu); Console.ReadKey(); }
public async void CreateUser() { // Create user var originalUser = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; IdentityResult result = await UserManager.CreateAsync(originalUser); result.ShouldBeSuccess(); // Try to find users by id and username CassandraUser foundUser = await UserManager.FindByIdAsync(originalUser.Id); foundUser.ShouldBeEquivalentToUser(originalUser); foundUser = await UserManager.FindByNameAsync(originalUser.UserName); foundUser.ShouldBeEquivalentToUser(originalUser); }
public async void GetSetLockoutEndDate() { // Create a user and enable lockout var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); await UserManager.SetLockoutEnabledAsync(user.Id, true); // Should be able to set lockout end date DateTimeOffset lockoutDate = DateTimeOffset.UtcNow; IdentityResult result = await UserManager.SetLockoutEndDateAsync(user.Id, lockoutDate); result.ShouldBeSuccess(); // Should be able to retrieve that lockout date DateTimeOffset lookupDate = await UserManager.GetLockoutEndDateAsync(user.Id); lookupDate.Should().BeCloseTo(lockoutDate); // Use CloseTo because C* is not accurate down to the ticks level }
public async Task DeleteUserAsync(CassandraUser user, CancellationToken cancellationToken = default(CancellationToken)) { if (user == null) { throw new ArgumentNullException("user"); } if (string.IsNullOrEmpty(user.UserName)) { throw new ArgumentNullException("user", "user.UserName cannot be null or empty"); } var foundUserResult = await FindUserByUserNameAsync(user.UserName, cancellationToken); var foundUserlist = foundUserResult.ToList(); if (!foundUserlist.Any()) { return; } user = foundUserlist[0]; var batch = new BatchStatement(); PreparedStatement prepared = await _deleteUserById; BoundStatement bound = prepared.Bind(user.Id); batch.Add(bound); prepared = await _deleteUserByEmail; bound = prepared.Bind(user.Email); batch.Add(bound); prepared = await _deleteUserByUserName; bound = prepared.Bind(user.UserName); batch.Add(bound); await RemoveLoginsFromUserAsync(user.Id, cancellationToken); await DeleteUserFromRolesAsync(user.Id, cancellationToken); await DeleteClaimHandleByUserIdAsync(user.Id, cancellationToken); await CassandraSession.ExecuteAsync(batch).ConfigureAwait(false); }
public async Task Test_Add_User_Find_by_userid_Delete_User_Async() { var dao = Global.TenantDao; await dao.EstablishConnectionAsync(); List <CassandraUser> insertedUsers = new List <CassandraUser>(); int nCount = 1; for (int i = 0; i < nCount; ++i) { string userName = Guid.NewGuid().ToString(); var user = new CassandraUser() { Email = userName, UserName = userName }; insertedUsers.Add(user); await dao.UpsertUserAsync(user); } foreach (var testUser in insertedUsers) { testUser.TenantId = dao.TenantId; var foundUserResult = await dao.FindUserByIdAsync(testUser.Id); Assert.IsNotNull(foundUserResult); var foundUserList = foundUserResult.ToList(); Assert.IsTrue(foundUserList.Any()); Assert.AreEqual(foundUserList.Count, 1); var foundUser = foundUserList[0]; Assert.IsTrue(CassandraUserComparer.ShallowComparer.Equals(foundUser, testUser)); } foreach (var testUser in insertedUsers) { await dao.DeleteUserAsync(testUser); var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email); Assert.IsNotNull(foundUserResult); var foundUserList = foundUserResult.ToList(); Assert.IsFalse(foundUserList.Any()); Assert.AreEqual(foundUserList.Count, 0); } }
public async void HasPassword() { // Create a user var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); // Verify they are created without a password bool hasPassword = await UserManager.HasPasswordAsync(user.Id); hasPassword.Should().BeFalse(); // Create a user with a password user = new CassandraUser(Guid.NewGuid()) {UserName = "******"}; await UserManager.CreateAsync(user, "somePassword"); // Verify they have a password hasPassword = await UserManager.HasPasswordAsync(user.Id); hasPassword.Should().BeTrue(); }
public async void GetSetLockoutEnabled() { // Create a user var user = new CassandraUser(Guid.NewGuid()) {UserName = "******"}; await UserManager.CreateAsync(user); // Lockout should not be enabled by default bool isLockoutEnabled = await UserManager.GetLockoutEnabledAsync(user.Id); isLockoutEnabled.Should().BeFalse(); // Should be able to turn on lockout for a user IdentityResult result = await UserManager.SetLockoutEnabledAsync(user.Id, true); result.ShouldBeSuccess(); // Should now be enabled isLockoutEnabled = await UserManager.GetLockoutEnabledAsync(user.Id); isLockoutEnabled.Should().BeTrue(); }
public async void DeleteUser() { // Create user, then lookup by Id var originalUser = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(originalUser); CassandraUser foundUser = await UserManager.FindByIdAsync(originalUser.Id); // Delete the user IdentityResult result = await UserManager.DeleteAsync(foundUser); result.ShouldBeSuccess(); // Should not be able to find by id or username foundUser = await UserManager.FindByIdAsync(originalUser.Id); foundUser.Should().BeNull(); foundUser = await UserManager.FindByNameAsync(originalUser.UserName); foundUser.Should().BeNull(); }
public async void EnableDisableTwoFactor() { // Create a user var user = new CassandraUser(Guid.NewGuid()) {UserName = "******"}; await UserManager.CreateAsync(user); // 2FA should be disabled by default bool isEnabled = await UserManager.GetTwoFactorEnabledAsync(user.Id); isEnabled.Should().BeFalse(); // Can set 2FA enabled IdentityResult result = await UserManager.SetTwoFactorEnabledAsync(user.Id, true); result.ShouldBeSuccess(); // Should be enabled now isEnabled = await UserManager.GetTwoFactorEnabledAsync(user.Id); isEnabled.Should().BeTrue(); }
public async void AddRemovePassword() { // Create user without password var user = new CassandraUser(Guid.NewGuid()) {UserName = "******"}; await UserManager.CreateAsync(user); // Adding a password should succeed IdentityResult result = await UserManager.AddPasswordAsync(user.Id, "somePassword"); result.ShouldBeSuccess(); bool hasPassword = await UserManager.HasPasswordAsync(user.Id); hasPassword.Should().BeTrue(); // Now removing a password should succeed result = await UserManager.RemovePasswordAsync(user.Id); result.ShouldBeSuccess(); hasPassword = await UserManager.HasPasswordAsync(user.Id); hasPassword.Should().BeFalse(); }
public async void LockUserOut() { // Create a user and enable lockout var user = new CassandraUser(Guid.NewGuid()) {UserName = "******"}; await UserManager.CreateAsync(user); await UserManager.SetLockoutEnabledAsync(user.Id, true); // Should be able to record a failed login IdentityResult result = await UserManager.AccessFailedAsync(user.Id); result.ShouldBeSuccess(); // Since the test setup uses one as the threshold for lockouts, the user should now be locked out bool isLockedOut = await UserManager.IsLockedOutAsync(user.Id); isLockedOut.Should().BeTrue(); // Since the test setup set the lockout period to 15 mins, the lockout end date should be approximately 15 mins from now DateTimeOffset lockoutEndDate = await UserManager.GetLockoutEndDateAsync(user.Id); lockoutEndDate.Should().BeCloseTo(DateTimeOffset.UtcNow.Add(15.Minutes()), precision: 1000); // 1000 == Within 1 second }
public async void GetAndSetEmail() { // Create a user var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); // User should not have an email address initially string userEmail = await UserManager.GetEmailAsync(user.Id); userEmail.Should().BeNullOrEmpty(); // Set email address for user const string email = "*****@*****.**"; IdentityResult result = await UserManager.SetEmailAsync(user.Id, email); result.ShouldBeSuccess(); // Now user should have email userEmail = await UserManager.GetEmailAsync(user.Id); userEmail.Should().Be(email); }
public async void GetSetPhoneNumber() { // Create a user var user = new CassandraUser(Guid.NewGuid()) {UserName = "******"}; await UserManager.CreateAsync(user); // Should not have phone number by default string phoneNumber = await UserManager.GetPhoneNumberAsync(user.Id); phoneNumber.Should().BeNullOrEmpty(); // Can set phone number const string phone = "555-555-1212"; IdentityResult result = await UserManager.SetPhoneNumberAsync(user.Id, phone); result.ShouldBeSuccess(); // Should now have phone number phoneNumber = await UserManager.GetPhoneNumberAsync(user.Id); phoneNumber.Should().Be(phone); }
public async Task Test_add_user_modify_twofactor_enabled_delete() { var dao = Global.TenantDao; await dao.EstablishConnectionAsync(); var guidId = Guid.NewGuid(); var userStore = new CassandraUserStore(); string userName = Guid.NewGuid().ToString(); var user = new CassandraUser() { Email = userName, UserName = userName, EmailConfirmed = false, PhoneNumberConfirmed = false, PhoneNumber = "310.383.1111", LockoutEnabled = false, PasswordHash = "1234", SecurityStamp = "1234", TwoFactorEnabled = false }; await userStore.CreateAsync(user); var foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNotNull(foundUser); Assert.IsFalse(await userStore.GetTwoFactorEnabledAsync(foundUser)); await userStore.SetTwoFactorEnabledAsync(foundUser, true); await userStore.UpdateAsync(foundUser); foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNotNull(foundUser); Assert.IsTrue(await userStore.GetTwoFactorEnabledAsync(foundUser)); await userStore.DeleteAsync(foundUser); foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNull(foundUser); }
public async void ChangePassword() { // Create a user with a password var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user, "somePassword"); // Should be able to change the password IdentityResult result = await UserManager.ChangePasswordAsync(user.Id, "somePassword", "someNewPassword"); result.ShouldBeSuccess(); // Should be able to authenticate with new password user = await UserManager.FindByIdAsync(user.Id); bool authenticated = await UserManager.CheckPasswordAsync(user, "someNewPassword"); authenticated.Should().BeTrue(); // Should not be able to authenticate with old password authenticated = await UserManager.CheckPasswordAsync(user, "somePassword"); authenticated.Should().BeFalse(); }
public async void FindByEmail() { // Create a user and set their email address const string email = "*****@*****.**"; var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); await UserManager.SetEmailAsync(user.Id, email); // User should be able to be looked up by email CassandraUser foundUser = await UserManager.FindByEmailAsync(email); foundUser.ShouldBeEquivalentToUser(user); // Delete the user await UserManager.DeleteAsync(foundUser); // User should no longer be able to be found by email foundUser = await UserManager.FindByEmailAsync(email); foundUser.Should().BeNull(); }
public static void Menu(string e, CassandraUser cu) { Console.WriteLine("Do you want to:\n 1-Find new friend \n " + "2-Write a post\n" + "3-Look over s-bodies post\n" + "4-Go out"); var x = Console.ReadLine(); switch (x) { case "1": Console.WriteLine("Write name of searched person "); string N = Console.ReadLine(); Console.WriteLine("Write surname now"); string S = Console.ReadLine(); cu.ToFollow(N, S, e); Menu(e, cu); break; case "3": Console.WriteLine("Write name of searched person "); N = Console.ReadLine(); Console.WriteLine("Write surname now"); S = Console.ReadLine(); cu.PostReaction(N, S, e); Menu(e, cu); break; case "2": var post = cu.CreatePost(e); Menu(e, cu); break; case "4": Console.WriteLine("Bye:("); Thread.Sleep(1000); System.Environment.Exit(20); break; } }
public async Task<ActionResult> Register(RegisterViewModel model) { if (ModelState.IsValid) { var user = new CassandraUser { UserName = model.UserName, Id = CassandraUser.GenerateKey(model.UserName)}; var result = await UserManager.CreateAsync(user, model.Password); if (result.Succeeded) { await SignInAsync(user, isPersistent: false); return RedirectToAction("Index", "Home"); } else { AddErrors(result); } } // If we got this far, something failed, redisplay form return View(model); }
public async Task Test_add_user_modify_password_hash_delete() { var dao = Global.TenantDao; await dao.EstablishConnectionAsync(); var guidId = Guid.NewGuid(); var userStore = new CassandraUserStore(); string userName = Guid.NewGuid().ToString(); var user = new CassandraUser() { Email = userName, UserName = userName, EmailConfirmed = false, PhoneNumberConfirmed = false, PhoneNumber = "310.383.1111", LockoutEnabled = false, PasswordHash = "1234" }; await userStore.CreateAsync(user); var foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNotNull(foundUser); Assert.AreEqual(await userStore.GetPasswordHashAsync(foundUser), "1234"); await userStore.SetPasswordHashAsync(foundUser, "abcd"); await userStore.UpdateAsync(foundUser); foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNotNull(foundUser); Assert.AreEqual(await userStore.GetPasswordHashAsync(foundUser), "abcd"); await userStore.DeleteAsync(foundUser); foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNull(foundUser); }
public async void PhoneNumberConfirmation() { // Create a user with a phone number const string phone = "555-555-1212"; var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); await UserManager.SetPhoneNumberAsync(user.Id, phone); // Should not be confirmed by default bool isConfirmed = await UserManager.IsPhoneNumberConfirmedAsync(user.Id); isConfirmed.Should().BeFalse(); // Generate a token to verify the phone number string token = await UserManager.GenerateChangePhoneNumberTokenAsync(user.Id, phone); IdentityResult result = await UserManager.ChangePhoneNumberAsync(user.Id, phone, token); result.ShouldBeSuccess(); // Phone number should now be confirmed isConfirmed = await UserManager.IsPhoneNumberConfirmedAsync(user.Id); isConfirmed.Should().BeTrue(); }
public async void ChangeEmail() { // Create a user and set their email address const string email = "*****@*****.**"; var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); await UserManager.SetEmailAsync(user.Id, email); // Change their email address const string newEmail = "*****@*****.**"; IdentityResult result = await UserManager.SetEmailAsync(user.Id, newEmail); result.ShouldBeSuccess(); // Should not be able to find the user by the old email address CassandraUser foundUser = await UserManager.FindByEmailAsync(email); foundUser.Should().BeNull(); // Should be able to find the user by the new email address foundUser = await UserManager.FindByEmailAsync(newEmail); foundUser.ShouldBeEquivalentToUser(user); }
public async Task Test_add_user_modify_phone_confirmed_delete() { var dao = Global.TenantDao; await dao.EstablishConnectionAsync(); var guidId = Guid.NewGuid(); var userStore = new CassandraUserStore(); string userName = Guid.NewGuid().ToString(); var user = new CassandraUser() { Email = userName, UserName = userName, EmailConfirmed = false, PhoneNumberConfirmed = false }; await userStore.CreateAsync(user); var foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNotNull(foundUser); Assert.IsFalse(await userStore.GetPhoneNumberConfirmedAsync(foundUser)); await userStore.SetPhoneNumberConfirmedAsync(foundUser, true); await userStore.UpdateAsync(foundUser); foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNotNull(foundUser); Assert.IsTrue(await userStore.GetPhoneNumberConfirmedAsync(foundUser)); await userStore.DeleteAsync(foundUser); foundUser = await userStore.FindByEmailAsync(userName); Assert.IsNull(foundUser); }
public async void AddRemoveLogins() { // Create a user var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); // Should not have any logins intially IList<UserLoginInfo> logins = await UserManager.GetLoginsAsync(user.Id); logins.Should().BeEmpty(); // Add some logins for the user and make sure we can retrieve them var loginsToAdd = new[] { new UserLoginInfo("facebook", Guid.NewGuid().ToString()), new UserLoginInfo("google", Guid.NewGuid().ToString()) }; IdentityResult result; foreach (UserLoginInfo login in loginsToAdd) { result = await UserManager.AddLoginAsync(user.Id, login); result.ShouldBeSuccess(); } logins = await UserManager.GetLoginsAsync(user.Id); logins.Should().NotBeEmpty() .And.HaveCount(loginsToAdd.Length); logins.ShouldAllBeEquivalentTo(loginsToAdd); // Now remove one of the logins from the user result = await UserManager.RemoveLoginAsync(user.Id, loginsToAdd[0]); result.ShouldBeSuccess(); logins = await UserManager.GetLoginsAsync(user.Id); logins.Should().NotBeEmpty() .And.HaveCount(loginsToAdd.Length - 1); logins.ShouldAllBeEquivalentTo(loginsToAdd.Where((_, idx) => idx != 0)); }
public async void AddRemoveClaims() { // Create a user var user = new CassandraUser(Guid.NewGuid()) {UserName = "******"}; await UserManager.CreateAsync(user); // User should not have any claims initially IList<Claim> claims = await UserManager.GetClaimsAsync(user.Id); claims.Should().BeEmpty(); // Should be able to add claims to user and retrieve them var claimsToAdd = new[] { new Claim("hometown", "Cincinnati, OH"), new Claim("dob", "4/16/1983") }; IdentityResult result; foreach (Claim claim in claimsToAdd) { result = await UserManager.AddClaimAsync(user.Id, claim); result.ShouldBeSuccess(); } claims = await UserManager.GetClaimsAsync(user.Id); claims.Should().NotBeEmpty() .And.HaveCount(claimsToAdd.Length); claims.ShouldAllBeEquivalentTo(claimsToAdd); // Should be able to remove a claim and get the correct claims back result = await UserManager.RemoveClaimAsync(user.Id, claimsToAdd[0]); result.ShouldBeSuccess(); claims = await UserManager.GetClaimsAsync(user.Id); claims.Should().NotBeEmpty() .And.HaveCount(claimsToAdd.Length - 1); claims.ShouldAllBeEquivalentTo(claimsToAdd.Where((_, idx) => idx != 0)); }
public async Task UpsertUserAsync(CassandraUser user, CancellationToken cancellationToken = default(CancellationToken)) { if (user == null) { throw new ArgumentNullException("user"); } if (string.IsNullOrEmpty(user.UserName)) { throw new ArgumentNullException("user", "user.UserName cannot be null or empty"); } var now = DateTimeOffset.UtcNow; var foundUserResult = await FindUserByEmailAsync(user.Email, cancellationToken); var foundUserList = foundUserResult.ToList(); if (foundUserList.Any()) { // we have an update, and not a create. // we don't let you update the username/email. That is done by ChangeUserNameAsync var foundUser = foundUserList[0]; user.Email = foundUser.Email; user.UserName = foundUser.UserName; } else { // We have a brand new user, // we want to make the Id and user record immutable. // This allows us to change out the email address, which is the only thing we will allow for what looks like a username. user.Id = Guid.NewGuid(); user.Created = now; } user.Modified = now; var batch = new BatchStatement(); var prepared = await _createUserByUserName; var bound = prepared.Bind(user.UserName, user.Id, user.PasswordHash, user.SecurityStamp, user.TwoFactorEnabled, user.AccessFailedCount, user.LockoutEnabled, user.LockoutEndDate, user.PhoneNumber, user.PhoneNumberConfirmed, user.Email, user.EmailConfirmed, user.Created, user.Modified, user.Enabled, user.Source, user.SourceId); batch.Add(bound); prepared = await _createUserByEmail; bound = prepared.Bind(user.UserName, user.Id, user.PasswordHash, user.SecurityStamp, user.TwoFactorEnabled, user.AccessFailedCount, user.LockoutEnabled, user.LockoutEndDate, user.PhoneNumber, user.PhoneNumberConfirmed, user.Email, user.EmailConfirmed, user.Created, user.Modified, user.Enabled, user.Source, user.SourceId); batch.Add(bound); prepared = await _createUserById; bound = prepared.Bind(user.UserName, user.Id, user.PasswordHash, user.SecurityStamp, user.TwoFactorEnabled, user.AccessFailedCount, user.LockoutEnabled, user.LockoutEndDate, user.PhoneNumber, user.PhoneNumberConfirmed, user.Email, user.EmailConfirmed, user.Created, user.Modified, user.Enabled, user.Source, user.SourceId); batch.Add(bound); cancellationToken.ThrowIfCancellationRequested(); await CassandraSession.ExecuteAsync(batch).ConfigureAwait(false); }
public async void EmailConfirmation() { // Create a user and set their email address const string email = "*****@*****.**"; var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user); await UserManager.SetEmailAsync(user.Id, email); // Email should NOT be confirmed by default bool confirmed = await UserManager.IsEmailConfirmedAsync(user.Id); confirmed.Should().BeFalse(); // Generate a token and confirm the email string token = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id); IdentityResult result = await UserManager.ConfirmEmailAsync(user.Id, token); result.ShouldBeSuccess(); // Email should now be confirmed confirmed = await UserManager.IsEmailConfirmedAsync(user.Id); confirmed.Should().BeTrue(); }
public async void ResetPassword() { // Create a user with a password var user = new CassandraUser(Guid.NewGuid()) { UserName = "******" }; await UserManager.CreateAsync(user, "somePassword"); // Generate a reset token and then reset the password should succeed string token = await UserManager.GeneratePasswordResetTokenAsync(user.Id); IdentityResult result = await UserManager.ResetPasswordAsync(user.Id, token, "someNewPassword"); result.ShouldBeSuccess(); // Should now be able to authenticate with new password user = await UserManager.FindByIdAsync(user.Id); bool authenticated = await UserManager.CheckPasswordAsync(user, "someNewPassword"); authenticated.Should().BeTrue(); // Should not be able to authenticate with old password authenticated = await UserManager.CheckPasswordAsync(user, "somePassword"); authenticated.Should().BeFalse(); }
public async Task<ActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl) { if (User.Identity.IsAuthenticated) { return RedirectToAction("Manage"); } if (ModelState.IsValid) { // Get the information about the user from the external login provider var info = await AuthenticationManager.GetExternalLoginInfoAsync(); if (info == null) { return View("ExternalLoginFailure"); } var user = new CassandraUser { UserName = model.UserName, Id = CassandraUser.GenerateKey(model.UserName)}; var result = await UserManager.CreateAsync(user); if (result.Succeeded) { result = await UserManager.AddLoginAsync(user.Id, info.Login); if (result.Succeeded) { await SignInAsync(user, isPersistent: false); return RedirectToLocal(returnUrl); } } AddErrors(result); } ViewBag.ReturnUrl = returnUrl; return View(model); }
private async Task SignInAsync(CassandraUser user, bool isPersistent) { AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie); var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie); AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, identity); }
/// <summary> /// Asserts that the user should have the same Id and UserName as the other user. /// </summary> public static void ShouldBeEquivalentToUser(this CassandraUser user, CassandraUser otherUser) { user.ShouldBeEquivalentTo(otherUser, opt => opt.Including(u => u.Id).Including(u => u.UserName)); }
public async Task <ActionResult> ExternalLoginCallback(string returnUrl) { var confirmEmailViewModel = Session[WellKnown.ConfirmEmailViewModelClaim] as ConfirmEmailViewModel; Session[WellKnown.ConfirmEmailViewModelClaim] = null; var loginInfo = await AuthenticationManager.GetExternalLoginInfoAsync(); if (loginInfo == null) { return(RedirectToAction("Login")); } CassandraUser user = await UserManager.FindAsync(loginInfo.Login); // Try an auto association. If this login provider provides and email, than try a match if (user == null && !string.IsNullOrEmpty(loginInfo.Email)) { user = await UserManager.FindByEmailAsync(loginInfo.Email); if (user != null) { // got a match. lets auto associate await UserManager.AddLoginAsync(user.Id, loginInfo.Login); } } if (user != null && !user.EmailConfirmed) { if (confirmEmailViewModel != null && string.Compare(user.Email, confirmEmailViewModel.Email, StringComparison.OrdinalIgnoreCase) == 0) { user.EmailConfirmed = true; await UserManager.UpdateAsync(user); } else { return (await SendEmailConfirmationCode(new ConfirmEmailViewModel() { ConfirmEmailPurpose = ConfirmEmailPurpose.ConfirmEmailPurpose_CreateExternalAccount, Email = user.Email, UserId = user.Id.ToString() })); } } // PreVerified Email Address Create/Association if (user == null && confirmEmailViewModel != null) { user = new ApplicationUser { UserName = confirmEmailViewModel.Email, Email = confirmEmailViewModel.Email, EmailConfirmed = true }; var resultCreate = await UserManager.CreateAsync(user); if (resultCreate.Succeeded) { resultCreate = await UserManager.AddLoginAsync(user.Id, loginInfo.Login); } Session[WellKnown.ConfirmEmailViewModelClaim] = null; } // Sign in the user with this external login provider if the user already has a login var result = await SignInManager.ExternalSignInAsync(loginInfo, isPersistent : false); switch (result) { case SignInStatus.Success: return(RedirectToLocal(returnUrl)); case SignInStatus.LockedOut: return(View("Lockout")); case SignInStatus.RequiresVerification: return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = false })); case SignInStatus.Failure: default: // If the user does not have an account, then prompt the user to create an account ViewBag.ReturnUrl = returnUrl; ViewBag.LoginProvider = loginInfo.Login.LoginProvider; Session["UserLoginInfo"] = loginInfo.Login; return(View("ExternalLoginConfirmation", new ExternalLoginConfirmationViewModel { Email = loginInfo.Email })); } }
public async Task Test_add_many_users_page_delete() { var dao = Global.TenantDao; await dao.EstablishConnectionAsync(); var guidId = Guid.NewGuid(); var insertedUsers = new List <CassandraUser>(); var role = new CassandraRole() { Name = Guid.NewGuid().ToString(), IsGlobal = false, }; var roleStore = Global.TanantCassandraRoleStore; var userStore = Global.TanantCassandraUserStore; await roleStore.CreateAsync(role); int nCount = 100; for (int i = 0; i < nCount; ++i) { string userName = Guid.NewGuid().ToString(); var user = new CassandraUser() { Email = userName, UserName = userName }; insertedUsers.Add(user); await userStore.CreateAsync(user); var providerLoginHandle = new ProviderLoginHandle() { LoginProvider = Guid.NewGuid().ToString(), ProviderKey = Guid.NewGuid().ToString(), UserId = user.Id }; await userStore.AddLoginAsync(user, new UserLoginInfo(providerLoginHandle.LoginProvider, providerLoginHandle.ProviderKey)); var claimHandle = new ClaimHandle() { Type = "Type:" + guidId, UserId = user.Id, Value = "Value:" + guidId }; await userStore.AddClaimAsync(user, new Claim(claimHandle.Type, claimHandle.Value)); await userStore.AddToRoleAsync(user, role.Name); } byte[] pageState = null; int pageSize = 9; var result = await userStore.PageUsersAsync(pageSize, pageState); pageState = result.PagingState; int nCounter = result.Count; while (pageState != null) { result = await userStore.PageUsersAsync(pageSize, pageState); pageState = result.PagingState; nCounter += result.Count; } Assert.AreEqual(nCounter, nCount); foreach (var testUser in insertedUsers) { await dao.DeleteUserAsync(testUser); var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email); Assert.IsNotNull(foundUserResult); var foundUserList = foundUserResult.ToList(); Assert.IsFalse(foundUserList.Any()); Assert.AreEqual(foundUserList.Count, 0); var roleResult = await dao.FindRoleNamesByUserIdAsync(testUser.Id); Assert.IsNotNull(roleResult); var roleResultList = roleResult.ToList(); Assert.IsFalse(roleResultList.Any()); var claimResult = await dao.FindClaimHandleByUserIdAsync(testUser.Id); Assert.IsNotNull(claimResult); var claimResultList = claimResult.ToList(); Assert.IsFalse(claimResultList.Any()); } await roleStore.DeleteAsync(role); var findDeletedRole = await roleStore.FindByNameAsync(role.Name); Assert.IsNull(findDeletedRole); }
public async Task Test_Add_Full_User_Find_by_email_Delete_User_Async() { var dao = Global.TenantDao; await dao.EstablishConnectionAsync(); var guidId = Guid.NewGuid(); var insertedUsers = new List <CassandraUser>(); var role = new CassandraRole() { Name = Guid.NewGuid().ToString(), IsGlobal = false, }; await dao.CreateRoleAsync(role); var roleNameResult = await dao.FindRoleByNameAsync(role.Name); Assert.IsNotNull(roleNameResult); var foundRoleNameResult = roleNameResult.ToList(); Assert.IsTrue(foundRoleNameResult.Any()); Assert.AreEqual(role.Name, foundRoleNameResult[0].Name); int nCount = 1; for (int i = 0; i < nCount; ++i) { string userName = Guid.NewGuid().ToString(); var user = new CassandraUser() { Email = userName, UserName = userName }; insertedUsers.Add(user); await dao.UpsertUserAsync(user); var providerLoginHandle = new ProviderLoginHandle() { LoginProvider = Guid.NewGuid().ToString(), ProviderKey = Guid.NewGuid().ToString(), UserId = user.Id }; await dao.UpsertLoginsAsync(providerLoginHandle); var claimHandle = new ClaimHandle() { Type = "Type:" + guidId, UserId = user.Id, Value = "Value:" + guidId }; await dao.CreateClaimAsync(claimHandle); await dao.AddToRoleAsync(user.Id, role.Name); } foreach (var testUser in insertedUsers) { testUser.TenantId = dao.TenantId; var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email); Assert.IsNotNull(foundUserResult); var foundUserList = foundUserResult.ToList(); Assert.IsTrue(foundUserList.Any()); Assert.AreEqual(foundUserList.Count, 1); var foundUser = foundUserList[0]; Assert.IsTrue(CassandraUserComparer.ShallowComparer.Equals(foundUser, testUser)); var roleResult = await dao.FindRoleNamesByUserIdAsync(testUser.Id); Assert.IsNotNull(roleResult); var roleResultList = roleResult.ToList(); Assert.AreEqual(1, roleResultList.Count()); var foundRole = roleResultList[0]; Assert.AreEqual(foundRole, role.Name); var claimResult = await dao.FindClaimHandleByUserIdAsync(testUser.Id); Assert.IsNotNull(claimResult); var claimResultList = claimResult.ToList(); Assert.AreEqual(1, claimResultList.Count()); var foundClaim = claimResultList[0]; var claimHandle = new ClaimHandle() { Type = "Type:" + guidId, UserId = testUser.Id, Value = "Value:" + guidId }; Assert.IsTrue(ClaimHandleComparer.Comparer.Equals(foundClaim, claimHandle)); } foreach (var testUser in insertedUsers) { await dao.DeleteUserAsync(testUser); var foundUserResult = await dao.FindUserByEmailAsync(testUser.Email); Assert.IsNotNull(foundUserResult); var foundUserList = foundUserResult.ToList(); Assert.IsFalse(foundUserList.Any()); Assert.AreEqual(foundUserList.Count, 0); var roleResult = await dao.FindRoleNamesByUserIdAsync(testUser.Id); Assert.IsNotNull(roleResult); var roleResultList = roleResult.ToList(); Assert.IsFalse(roleResultList.Any()); var claimResult = await dao.FindClaimHandleByUserIdAsync(testUser.Id); Assert.IsNotNull(claimResult); var claimResultList = claimResult.ToList(); Assert.IsFalse(claimResultList.Any()); } await dao.DeleteRoleAsync(role); roleNameResult = await dao.FindRoleByNameAsync(role.Name); Assert.IsNotNull(roleNameResult); foundRoleNameResult = roleNameResult.ToList(); Assert.IsFalse(foundRoleNameResult.Any()); }
public async Task UpdateUserAsync(CassandraUser user) { var fullUserStore = UserManager.FullUserStore; await fullUserStore.UpdateAsync(user); }