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