public async Task<ActionResult> DisableUser(string userName) { List<string> users; List<string> enabledUsers; List<string> disabledUsers; using (var context = new ApplicationDbContext()) { var userStore = new UserStore<ApplicationUser>(context); var userManager = new UserManager<ApplicationUser>(userStore); var selectedUser = userManager.FindByName(userName); if (selectedUser == null) throw new Exception("User not found!"); if (!selectedUser.UserName.Equals("*****@*****.**")) { if (!selectedUser.LockoutEnabled) { userManager.SetLockoutEnabled(selectedUser.Id, true); DateTime lockoutDate = DateTime.Now.AddYears(50); await userManager.SetLockoutEndDateAsync(selectedUser.Id, lockoutDate); context.SaveChanges(); userManager.Update(selectedUser); ViewBag.ResultMessage = "Disabled successfully !"; } } else { ViewBag.ResultMessage = "Cannot disable Admin"; } users = (from u in userManager.Users select u.UserName).ToList(); disabledUsers = new List<string>(users); enabledUsers = new List<string>(users); foreach (var user in users) { if (!userManager.FindByName(user).LockoutEnabled) { disabledUsers.Remove(user); } else { enabledUsers.Remove(user); } } } ViewBag.EnabledUsers = new SelectList(enabledUsers); ViewBag.DisabledUsers = new SelectList(disabledUsers); return View(); }
public async Task <IActionResult> Lock(string id) { var user = await _userManager.FindByIdAsync(id); var identityResult = await _userManager.SetLockoutEnabledAsync(user, true); if (!identityResult.Succeeded) { return(ResponseIdentityResultError(identityResult)); } identityResult = await _userManager.SetLockoutEndDateAsync(user, new DateTime(2100, 1, 1)); if (!identityResult.Succeeded) { return(ResponseIdentityResultError(identityResult)); } return(Ok()); }
public IActionResult BlockUser() { return(DoMainLogic((user) => { bool isActive = _userManager.GetLockoutEnabledAsync(user).Result; _userManager.SetLockoutEnabledAsync(user, true).Wait(); if (_userManager.GetLockoutEndDateAsync(user).Result > DateTime.Now) { _userManager.SetLockoutEndDateAsync(user, DateTime.Now).Wait(); } else { _userManager.SetLockoutEndDateAsync(user, DateTime.MaxValue).Wait(); } _userManager.SetLockoutEnabledAsync(user, isActive).Wait(); _userManager.UpdateAsync(user).Wait(); }, Url.Action("Users"))); }
public async Task <Message_Dto> lock_user(string UserName) { var user = await _userManager.FindByNameAsync(UserName); if (user == null) { return(null); } var lockoutEndDate = new DateTime(2999, 01, 01); await _userManager.SetLockoutEnabledAsync(user, true); await _userManager.SetLockoutEndDateAsync(user, lockoutEndDate); return(new Message_Dto { message_en = "User is lock", message_fr = "Utilisateur est bloque" }); }
public async Task <ActionResult <User> > LockoutUser([FromRoute] string id) { var user = await _context.ApplicationUsers.FindAsync(id); if (user == null) { return(NotFound()); } var result = await _userManager.SetLockoutEndDateAsync(user, DateTime.Now.AddYears(99)); if (!result.Succeeded) { return(BadRequest(result.Errors)); } return(NoContent()); }
public async Task Lockout(string user) { //AspNetUsers userObj = await _userManager.FindByIdAsync(user); await _userManager.SetLockoutEndDateAsync(await _userManager.FindByIdAsync(user), DateTime.UtcNow.AddMinutes(42)); //userObj.LockoutEnabled = true; //userObj.LockoutEnd = DateTime.UtcNow.AddMinutes(42); //await _userManager.UpdateAsync(userObj); }
public async Task <ActionResult> UnlockAccount([Bind(Include = "Id")] string id) { await UserManager.ResetAccessFailedCountAsync(id); await UserManager.SetLockoutEndDateAsync(id, DateTime.UtcNow.AddYears(-1)); TempData["AccountUnlocked"] = "Account was UnLocked successfully."; return(RedirectToAction("Index")); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = new ApplicationUser { UserName = Input.Email, Email = Input.Email, FirstName = Input.FirstName, LastName = Input.LastName, PhoneNumber = Input.PhoneNumber }; var result = await _userManager.CreateAsync(user, Input.Password); if (result.Succeeded) { if (!await _roleManager.RoleExistsAsync(StaticDetails.MechanicEndUser)) { await _roleManager.CreateAsync(new IdentityRole(StaticDetails.MechanicEndUser)); } if (Input.IsMechanic) { await _userManager.AddToRoleAsync(user, StaticDetails.MechanicEndUser); await _userManager.SetLockoutEndDateAsync(user, DateTime.Now.AddYears(1000)); } _logger.LogInformation("User created a new account with password."); var code = await _userManager.GenerateEmailConfirmationTokenAsync(user); var callbackUrl = Url.Page( "/Account/ConfirmEmail", pageHandler: null, values: new { userId = user.Id, code = code }, protocol: Request.Scheme); await _emailSender.SendEmailAsync(Input.Email, "Confirm your email", $"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>."); if (!Input.IsMechanic) { await _signInManager.SignInAsync(user, isPersistent : false); return(LocalRedirect(returnUrl)); } else { return(RedirectToAction("Index", "Home", new { area = "Customer" })); } } foreach (var error in result.Errors) { ModelState.AddModelError(string.Empty, error.Description); } } // If we got this far, something failed, redisplay form return(Page()); }
/// <summary> /// Lock/Unlock the Application user /// </summary> /// <param name="applicationUserId">Customer Id / Retailer Id</param> /// <param name="isLocked">Is Locked</param> /// <returns></returns> public async Task <bool> LockUnLockApplicationUser(string applicationUserId) { var user = await _userManager.FindByIdAsync(applicationUserId); bool isLocked = await _userManager.IsLockedOutAsync(user); var result = await _userManager.SetLockoutEnabledAsync(user, !isLocked); if (isLocked) { await _userManager.SetLockoutEndDateAsync(user, DateTime.Now.AddDays(-1)); } else { await _userManager.SetLockoutEndDateAsync(user, DateTime.Now.AddMinutes(15)); } return(result.Succeeded); }
public async Task <IActionResult> statechange(string id) { var user = await _userManager.FindByIdAsync(id); if (await _userManager.IsLockedOutAsync(user)) { await _userManager.SetLockoutEndDateAsync(user, new DateTimeOffset(DateTime.UtcNow)); } else { await _userManager.SetLockoutEndDateAsync(user, DateTime.FromOADate(365 * 200)); } await _adminrepository.statechange(id); return(RedirectToAction("Management")); }
public async Task <IHttpActionResult> AllowUser(string email) { var user = UserManager.Users.Single(u => u.Email == email); await UserManager.SetLockoutEndDateAsync(user.Id, DateTimeOffset.Now); await UserManager.SetLockoutEnabledAsync(user.Id, false); return(Ok(email + " will now have access to Sussol")); }
public async Task <IHttpActionResult> DenyUser(string email) { var user = UserManager.Users.Single(u => u.Email == email); await UserManager.SetLockoutEnabledAsync(user.Id, true); await UserManager.SetLockoutEndDateAsync(user.Id, DateTimeOffset.MaxValue); return(Ok(email + " is blocked from Sussol")); }
private Task <bool> LockAsync(IUser user, bool isFirst) { if (isFirst || !identityOptions.Value.LockAutomatically) { return(TaskHelper.True); } return(MakeIdentityOperation(() => userManager.SetLockoutEndDateAsync(user, DateTimeOffset.UtcNow.AddYears(100)))); }
public void LockoutEnabled() { UserStore <ApplicationUser, IdentityRole, IdentityCloudContext> store = CreateUserStore(); UserManager <ApplicationUser> manager = CreateUserManager(); var user = CurrentUser; var taskLockoutSet = manager.SetLockoutEnabledAsync(user, true); taskLockoutSet.Wait(); Assert.IsTrue(taskLockoutSet.Result.Succeeded, string.Concat(taskLockoutSet.Result.Errors)); DateTimeOffset offSet = new DateTimeOffset(DateTime.Now.AddMinutes(3)); var taskDateSet = manager.SetLockoutEndDateAsync(user, offSet); taskDateSet.Wait(); Assert.IsTrue(taskDateSet.Result.Succeeded, string.Concat(taskDateSet.Result.Errors)); var taskEnabledGet = manager.GetLockoutEnabledAsync(user); taskEnabledGet.Wait(); Assert.IsTrue(taskEnabledGet.Result, "Lockout not true"); var taskDateGet = manager.GetLockoutEndDateAsync(user); taskDateGet.Wait(); Assert.AreEqual(offSet, taskDateGet.Result); DateTime tmpDate = DateTime.UtcNow.AddDays(1); user.LockoutEnd = tmpDate; var taskGet = store.GetLockoutEndDateAsync(user); taskGet.Wait(); Assert.AreEqual <DateTimeOffset?>(new DateTimeOffset?(tmpDate), taskGet.Result); user.LockoutEnd = null; var taskGet2 = store.GetLockoutEndDateAsync(user); taskGet2.Wait(); Assert.AreEqual <DateTimeOffset?>(new DateTimeOffset?(), taskGet2.Result); var minOffSet = DateTimeOffset.MinValue; var taskSet2 = store.SetLockoutEndDateAsync(user, minOffSet); taskSet2.Wait(); Assert.IsNotNull(user.LockoutEnd); Assert.ThrowsException <ArgumentNullException>(() => store.GetLockoutEnabledAsync(null).Wait()); Assert.ThrowsException <ArgumentNullException>(() => store.GetLockoutEndDateAsync(null).Wait()); Assert.ThrowsException <ArgumentNullException>(() => store.SetLockoutEndDateAsync(null, offSet).Wait()); Assert.ThrowsException <ArgumentNullException>(() => store.SetLockoutEnabledAsync(null, false).Wait()); }
private Task <bool> LockAsync(UserWithClaims user, bool isFirst) { if (isFirst || !identityOptions.LockAutomatically) { return(Task.FromResult(true)); } return(MakeIdentityOperation(() => userManager.SetLockoutEndDateAsync(user.Identity, DateTimeOffset.UtcNow.AddYears(100)))); }
public async Task <ActionResult> LockUser(string id) { if (!String.IsNullOrEmpty(id)) { ApplicationUser user = await _userManager.FindByIdAsync(id); if (user != null) { string userInformation = string.Format("Username: {0}, Surname: {1}, Firstname: {2}, Middlename: {3}, Employeenumber: {4} ", user.UserName, user.Surname, user.FirstName, user.MiddleName, user.EmployeeNumber); bool isLockedOut = await _userManager.IsLockedOutAsync(user); if (!isLockedOut) { IdentityResult userResult = await _userManager.SetLockoutEndDateAsync(user, DateTimeOffset.MaxValue); if (userResult.Succeeded) { IdentityResult lockoutResult = await _userManager.SetLockoutEnabledAsync(user, true); if (lockoutResult.Succeeded) { _logger.LogWarning(LoggingEvents.UserConfiguration, LoggingErrorText.userLockSucceed, userInformation, _userManager.GetUserName(User)); } else { _logger.LogError(LoggingEvents.UserConfiguration, LoggingErrorText.userLockPartialFailed, userInformation, _userManager.GetUserName(User), GetDataErrors.GetErrors(userResult)); return(BadRequest(InformationMessages.userLockPartialFail)); } } else { _logger.LogError(LoggingEvents.UserConfiguration, LoggingErrorText.userLockFailed, userInformation, _userManager.GetUserName(User), GetDataErrors.GetErrors(userResult)); return(BadRequest(InformationMessages.userLockFail)); } } else { return(BadRequest(InformationMessages.userAlreadyLocked)); } } } return(Ok()); }
public async Task <ActionResult> DisableUser(string userName) { List <string> users; List <string> enabledUsers; List <string> disabledUsers; using (var context = new ApplicationDbContext()) { var userStore = new UserStore <ApplicationUser>(context); var userManager = new UserManager <ApplicationUser>(userStore); var selectedUser = userManager.FindByName(userName); if (selectedUser == null) { throw new Exception("User not found!"); } if (!selectedUser.UserName.Equals("*****@*****.**")) { if (!selectedUser.LockoutEnabled) { userManager.SetLockoutEnabled(selectedUser.Id, true); DateTime lockoutDate = DateTime.Now.AddYears(50); await userManager.SetLockoutEndDateAsync(selectedUser.Id, lockoutDate); context.SaveChanges(); userManager.Update(selectedUser); ViewBag.ResultMessage = "Disabled successfully !"; } } else { ViewBag.ResultMessage = "Cannot disable Admin"; } users = (from u in userManager.Users select u.UserName).ToList(); disabledUsers = new List <string>(users); enabledUsers = new List <string>(users); foreach (var user in users) { if (!userManager.FindByName(user).LockoutEnabled) { disabledUsers.Remove(user); } else { enabledUsers.Remove(user); } } } ViewBag.EnabledUsers = new SelectList(enabledUsers); ViewBag.DisabledUsers = new SelectList(disabledUsers); return(View()); }
public async Task <IActionResult> EditUser(UserViewModel model) { var modelId = model.Id.ToString(); var user = await _userManager.FindByIdAsync(modelId); if (user == null) { ViewBag.ErrorMessage = $"Couldn't find user with Id: {modelId}"; return(View("Error")); } user.UserName = model.UserName; user.FirstName = model.FirstName; user.LastName = model.LastName; user.DisplayName = model.DisplayName; user.DateOfBirth = Convert.ToDateTime(model.DateOfBirth); user.UserType = model.UserType; user.IsActive = model.IsActive; if (!user.IsActive) { await _userManager.SetLockoutEnabledAsync(user, true); await _userManager.SetLockoutEndDateAsync(user, DateTime.Today.AddDays(user.SuspensionTime)); } else { await _userManager.SetLockoutEnabledAsync(user, false); } var result = await _userManager.UpdateAsync(user); if (!result.Succeeded) { ViewBag.ErrorMessage = $"Error updating user with Id: {modelId}"; return(View("Error")); } await _userService.UpdateRole(user); await _userService.UpdateClaims(user); var loggedInUserId = User.FindFirst(ClaimTypes.NameIdentifier).Value; // refresh cookie if logged in user is modified if (user.Id == new Guid(loggedInUserId)) { var loggedinUser = await _userManager.FindByIdAsync(loggedInUserId); await _signInManager.SignOutAsync(); await _signInManager.SignInAsync(loggedinUser, true, ""); } return(RedirectToAction("Index")); }
public async Task <IActionResult> Login(LoginViewModel model) { if (ModelState.IsValid) { AppUser user = await _userManager.FindByEmailAsync(model.Email); if (user != null) { //İlgili kullanıcıya dair önceden oluşturulmuş bir Cookie varsa siliyoruz. await _signInManager.SignOutAsync(); Microsoft.AspNetCore.Identity.SignInResult result = await _signInManager.PasswordSignInAsync(user, model.Password, model.Persistent, false); if (result.Succeeded) { await _userManager.ResetAccessFailedCountAsync(user); //Önceki hataları girişler neticesinde +1 arttırılmış tüm değerleri 0(sıfır)a çekiyoruz. if (string.IsNullOrEmpty(TempData["returnUrl"] != null ? TempData["returnUrl"].ToString() : "")) { return(RedirectToAction("Index")); } return(Redirect(TempData["returnUrl"].ToString())); } else { await _userManager.AccessFailedAsync(user); //Eğer ki başarısız bir account girişi söz konusu ise AccessFailedCount kolonundaki değer +1 arttırılacaktır. int failcount = await _userManager.GetAccessFailedCountAsync(user); //Kullanıcının yapmış olduğu başarısız giriş deneme adedini alıyoruz. if (failcount == 3) { await _userManager.SetLockoutEndDateAsync(user, new DateTimeOffset(DateTime.Now.AddMinutes(1))); //Eğer ki başarısız giriş denemesi 3'ü bulduysa ilgili kullanıcının hesabını kitliyoruz. ModelState.AddModelError("Locked", "Art arda 3 başarısız giriş denemesi yaptığınızdan dolayı hesabınız 1 dk kitlenmiştir."); } else { if (result.IsLockedOut) { ModelState.AddModelError("Locked", "Art arda 3 başarısız giriş denemesi yaptığınızdan dolayı hesabınız 1 dk kitlenmiştir."); } else { ModelState.AddModelError("NotUser2", "E-posta veya şifre yanlış."); } } } } else { ModelState.AddModelError("NotUser", "Böyle bir kullanıcı bulunmamaktadır."); ModelState.AddModelError("NotUser2", "E-posta veya şifre yanlış."); } } return(View(model)); }
public async Task <IActionResult> OnPostAsync(string returnUrl = null) { returnUrl = returnUrl ?? Url.Content("~/"); if (ModelState.IsValid) { var user = await _userManager.FindByNameAsync(Input.UserName); Input.SecretPassword = Methods.Encrypt(Input.SecretPassword); if (user.SecretPassword.CompareTo(Input.SecretPassword) != 0 || user.Email.CompareTo(Input.Email) != 0) { ModelState.AddModelError(string.Empty, "Incorrect information."); await _userManager.AccessFailedAsync(user); return(Page()); } var result = await _signInManager.PasswordSignInAsync( user, Input.Password, isPersistent : false, lockoutOnFailure : false); if (result.Succeeded) { _logger.LogInformation("User logged in."); await _userManager.SetLockoutEndDateAsync(user, null); await _userManager.ResetAccessFailedCountAsync(user); return(RedirectToAction("Index", "UserHome")); } if (result.RequiresTwoFactor) { return(RedirectToPage("./LoginWith2fa", new { ReturnUrl = returnUrl, RememberMe = Input.RememberMe })); } if (result.IsLockedOut || user.LockoutEnd != null) { _logger.LogWarning("User account locked out, please contact the admin to unlock your account."); SendEmailToUser(user, "Account LockedOut"); return(RedirectToPage("./Lockout")); } else { ModelState.AddModelError(string.Empty, "Incorrect information."); await _userManager.AccessFailedAsync(user); return(Page()); } } //await _userManager.AccessFailedAsync(userInDB); // If we got this far, something failed, redisplay form return(Page()); }
// GET: Users/Lock/5 public async Task <ActionResult> LockUser(string id) { var userToLock = await _userManager.Users.FirstOrDefaultAsync(m => m.Id == id); await _userManager.SetLockoutEnabledAsync(userToLock, true); await _userManager.SetLockoutEndDateAsync(userToLock, DateTime.Today.AddYears(100)); return(View("Index", _userManager.Users.ToList())); }
public async Task <IActionResult> Deactivate(string id, ApplicationUserListViewModel model) { var applicationUser = await _userManager.FindByIdAsync(model.Id); await _userManager.SetLockoutEndDateAsync(applicationUser, DateTime.Today.AddYears(10)); await _context.SaveChangesAsync(); return(RedirectToAction("Index")); }
public async Task <IActionResult> Block(string[] selectedUsers) { foreach (string id in selectedUsers) { User iuser = await _userManager.FindByNameAsync(User.Identity.Name); User user = await _userManager.FindByIdAsync(id); if (user != null) { IdentityResult result = await _userManager.SetLockoutEndDateAsync(user, new DateTime(9999, 12, 30)); } if (iuser == user) { return(RedirectToAction("Login", "Account")); } } return(RedirectToAction("Index")); }
public async Task <IActionResult> UnlockAsync(string unlockId) { IdentityUser user = await _userManager.FindByIdAsync(unlockId).ConfigureAwait(false); // ロック解除 await _userManager.SetLockoutEndDateAsync(user, null).ConfigureAwait(false); // ロックを解除したユーザのページを表示 return(View("Index", new ManageViewModel(_userManager, user))); }
public async Task <IActionResult> UnlockUser(string userId) { var user = await GetUser(userId); if (user?.LockoutEnd > DateTimeNow()) { await _userManager.SetLockoutEndDateAsync(user, DateTimeNow().Date.AddDays(-1)); } return(RedirectToAction(nameof(Index))); }
public async Task <IActionResult> Index(string id, bool DisableLockout) { if (!string.IsNullOrEmpty(id) && DisableLockout) { var user = _userManager.FindByIdAsync(id).Result; await _userManager.SetLockoutEndDateAsync(user, DateTime.Now - TimeSpan.FromMinutes(1)); } return(View(await _userManager.Users.ToListAsync())); }
public async Task <ActionResult> Lockout(string id, UserLockoutViewModel viewModel) { try { if (ModelState.IsValid) { WebApplication2User user = await userManager.FindByIdAsync(id); if (user != null) { bool isLockedOut = await userManager.IsLockedOutAsync(user); if (isLockedOut) { return(RedirectToAction("Index")); } IdentityResult userResult = await userManager.SetLockoutEndDateAsync(user, DateTimeOffset.MaxValue); if (userResult.Succeeded) { IdentityResult lockoutResult = await userManager.SetLockoutEnabledAsync(user, true); if (lockoutResult.Succeeded) { return(RedirectToAction(nameof(Index))); } } else { AddErrors(userResult); return(View(viewModel)); } } } return(RedirectToAction(nameof(Index))); } catch (Exception ex) { ModelState.AddModelError(string.Empty, "There was an error"); return(View(viewModel)); } }
public static async Task UnlockAsync(this UserManager <IUser> userManager, string id) { var user = await userManager.FindByIdAsync(id); if (user == null) { throw new DomainObjectNotFoundException(id, typeof(IUser)); } await DoChecked(() => userManager.SetLockoutEndDateAsync(user, null), "Cannot unlock user."); }
/// <summary> /// Sets the user lockout end date /// </summary> /// <param name="manager"></param> /// <param name="userId"></param> /// <param name="lockoutEnd"></param> /// <returns></returns> public static IdentityResult SetLockoutEndDate <TUser, TKey>(this UserManager <TUser, TKey> manager, TKey userId, DateTimeOffset lockoutEnd) where TKey : IEquatable <TKey> where TUser : class, IUser <TKey> { if (manager == null) { throw new ArgumentNullException("manager"); } return(AsyncHelper.RunSync(() => manager.SetLockoutEndDateAsync(userId, lockoutEnd))); }
public async Task <ActionResult <IdentityResult> > LockUser([FromRoute] string userId) { //TODO: Add authorization checks var result = IdentityResult.Success; var user = await _userManager.FindByIdAsync(userId); if (user != null) { //Allow to register new users only within own organization var authorizationResult = await _authorizationService.AuthorizeAsync(User, user?.Contact?.Organization, CanEditOrganizationResourceAuthorizeRequirement.PolicyName); if (!authorizationResult.Succeeded) { return(Unauthorized()); } await _userManager.SetLockoutEndDateAsync(user, DateTimeOffset.MaxValue); } return(result); }
public async Task <IActionResult> SignIn([FromForm] LoginUserViewModel userViewModel, string ReturnUrl) { if (ModelState.IsValid) { var user = await _userManager.FindByNameAsync(userViewModel.UserName); if (user != null) { await _signInManager.SignOutAsync(); var result = await _signInManager.PasswordSignInAsync(user, userViewModel.PassWord, userViewModel.Persistent, true); if (result.Succeeded) { await _userManager.ResetAccessFailedCountAsync(user); if (!string.IsNullOrEmpty(ReturnUrl)) { return(Redirect(ReturnUrl)); } return(Redirect("~/")); } else { await _userManager.AccessFailedAsync(user); var failedCount = await _userManager.GetAccessFailedCountAsync(user); if (failedCount == Convert.ToInt32(configuration.GetCustomerMaxFailedAccessAttempts())) { await _userManager.SetLockoutEndDateAsync(user, new DateTimeOffset(DateTime.Now.AddMinutes(10))); ViewBag.Error = _localizer["UserLocked"]; } else { if (result.IsLockedOut) { ViewBag.Error = _localizer["UserLocked"]; } else { ViewBag.Error = _localizer["CheckYourLogin"]; } } } } else { ModelState.AddModelError("CheckYourLogin", _localizer["CheckYourLogin"]); } } return(View()); }
public async Task<JsonResult> BanUser(ManageUserViewModel model) { var context = new PhotoContestDbContext(); var store = new UserStore<User>(context); var manager = new UserManager<User>(store); await manager.SetLockoutEnabledAsync(model.Id, true); await manager.SetLockoutEndDateAsync(model.Id, DateTime.Now.AddDays(14)); return this.Json( string.Format("Successfully locked user {0}", model.UserName), JsonRequestBehavior.AllowGet); }
public void LockoutEnabled() { using (UserStore<IdentityUser> store = new UserStore<IdentityUser>()) { using (UserManager<IdentityUser> manager = new UserManager<IdentityUser>(store)) { manager.UserTokenProvider = new EmailTokenProvider<IdentityUser>(); var user = User; var taskLockoutSet = manager.SetLockoutEnabledAsync(user.Id, true); taskLockoutSet.Wait(); Assert.IsTrue(taskLockoutSet.Result.Succeeded, string.Concat(taskLockoutSet.Result.Errors)); DateTimeOffset offSet = new DateTimeOffset(DateTime.UtcNow.AddMinutes(3)); var taskDateSet = manager.SetLockoutEndDateAsync(user.Id, offSet); taskDateSet.Wait(); Assert.IsTrue(taskDateSet.Result.Succeeded, string.Concat(taskDateSet.Result.Errors)); var taskEnabledGet = manager.GetLockoutEnabledAsync(user.Id); taskEnabledGet.Wait(); Assert.IsTrue(taskEnabledGet.Result, "Lockout not true"); var taskDateGet = manager.GetLockoutEndDateAsync(user.Id); taskDateGet.Wait(); Assert.AreEqual(offSet,taskDateGet.Result, "Lockout date incorrect"); DateTime tmpDate = DateTime.UtcNow.AddDays(1); user.LockoutEndDateUtc = tmpDate; var taskGet = store.GetLockoutEndDateAsync(user); taskGet.Wait(); Assert.AreEqual<DateTimeOffset>(new DateTimeOffset(tmpDate), taskGet.Result, "LockoutEndDate not set"); user.LockoutEndDateUtc = null; var taskGet2 = store.GetLockoutEndDateAsync(user); taskGet2.Wait(); Assert.AreEqual<DateTimeOffset>(new DateTimeOffset(), taskGet2.Result, "LockoutEndDate not set"); var minOffSet = DateTimeOffset.MinValue; var taskSet2 = store.SetLockoutEndDateAsync(user, minOffSet); taskSet2.Wait(); Assert.IsNull(user.LockoutEndDateUtc, "LockoutEndDate not null"); try { store.GetLockoutEnabledAsync(null); } catch (ArgumentException) { } try { store.GetLockoutEndDateAsync(null); } catch (ArgumentException) { } try { store.SetLockoutEndDateAsync(null, offSet); } catch (ArgumentException) { } try { store.SetLockoutEnabledAsync(null, false); } catch (ArgumentException) { } } } }