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) { }
                }
            }
        }
Пример #3
0
        private async Task <ActionResult> createUser(UserEditModel model, bool IsActive)
        {
            if (ModelState.IsValid)
            {
                var locationExists = context.Locations.Any(loc => loc.State == model.SelectedState && loc.International == model.IsInternational);
                if (locationExists)
                {
                    model.LocationId = context.Locations.FirstOrDefault(loc => loc.State == model.SelectedState && loc.International == model.IsInternational).Id;
                }
                else if (!string.IsNullOrEmpty(model.SelectedState))
                {
                    model.LocationId = CreateLocation(model.SelectedState, model.IsInternational);
                }
                else
                {
                    model.LocationId = null;
                }

                var userNameExists = context.Users.Any(u => u.Id != model.Id && u.UserName == model.Username);
                if (userNameExists)
                {
                    ViewBag.BannerMessage = "This username is already in use.  Please try a different user name.";
                    ViewBag.BannerClass   = "alert-danger";
                    BuildCreateEditViewData();
                    return(View());
                }

                var emailExists = context.Users.Any(u => u.Id != model.Id && u.Email == model.Email);
                if (emailExists)
                {
                    ViewBag.BannerMessage = "The email provided is already associated with another account.  Please ensure the email address is correct.";
                    ViewBag.BannerClass   = "alert-danger";
                    BuildCreateEditViewData();
                    model.IsActive = IsActive;
                    return(View());
                }

                var result = _userManager.Create(new User {
                    UserName = model.Username
                }, model.Password ?? KeyGenerator.GetUniqueKey(6));
                if (result.Succeeded)
                {
                    var user = _userManager.FindByName(model.Username);

                    user.FirstName = model.FirstName;
                    user.LastName  = model.LastName;
                    user.Vendor    = context.Vendors.First(v => v.Id == model.VendorId);
                    user.Email     = model.Email;
                    user.IsActive  = IsActive;
                    await _userManager.SetLockoutEnabledAsync(user.Id, true);

                    if (model.LocationId != null)
                    {
                        user.Location = context.Locations.First(lo => lo.Id == model.LocationId);
                    }
                    var siteIds = new List <int>();
                    if (model.SiteList != null)
                    {
                        siteIds = model.SiteList.Split(',').Select(s => Convert.ToInt32(s)).ToList();
                    }

                    var systemIds = new List <int>();
                    if (model.SystemList != null)
                    {
                        systemIds = model.SystemList.Split(',').Select(s => Convert.ToInt32(s)).ToList();
                    }

                    user.userSiteAccess = context.Sites.Where(s => siteIds.Contains(s.Id)).ToList();
                    var newBuildingSystems = context.Buildings.SelectMany(b => b.Systems).Where(bs => systemIds.Contains(bs.Id)).ToList();

                    List <BuildingSystem> systemAdditions = new List <BuildingSystem>();
                    systemAdditions = newBuildingSystems.ToList();

                    foreach (var addition in systemAdditions)
                    {
                        user.BuildingSystems.Add(addition);
                    }

                    _userManager.AddToRole(user.Id, context.Roles.First(r => r.Id == model.RoleId).Name);
                    _userManager.Update(user);

                    model.Id = user.Id;

                    TempData["CreateSuccess"] = model.Username + " was created successfully";
                    return(RedirectToAction("Index"));
                }

                return(View(model));
            }

            return(View(model));
        }
Пример #4
0
        public static async Task InitializeDb(ApplicationDbContext context, UserManager <ApplicationUser> userManager, RoleManager <ApplicationRole> roleManager)
        {
            //context.Database.Migrate();
            //context.Database.EnsureCreated();
            // Add roles
            if (!await context.Roles.AnyAsync(r => string.Equals(r.Name, "System Administrator", StringComparison.OrdinalIgnoreCase)))
            {
                await roleManager.CreateAsync(new ApplicationRole { Name = "System Administrator", IsSysAdmin = true });
            }
            // Add Admin user
            var adminUser = userManager.Users.FirstOrDefault(u => string.Equals(u.UserName, "*****@*****.**", StringComparison.OrdinalIgnoreCase));

            if (adminUser == null)
            {
                adminUser = new ApplicationUser
                {
                    UserName  = "******",
                    Email     = "*****@*****.**",
                    FirstName = "Super",
                    LastName  = "Admin"
                };
                var result = await userManager.CreateAsync(adminUser, "P@ssword1");

                if (result != IdentityResult.Success)
                {
                    throw new Exception($"Unable to create '{adminUser.UserName}' account: {result}");
                }
            }
            await userManager.SetLockoutEnabledAsync(adminUser, false);

            // Check AdminUserRoles
            var adminRoles = await userManager.GetRolesAsync(adminUser);

            if (!adminRoles.Any(r => string.Equals(r, "System Administrator")))
            {
                await userManager.AddToRoleAsync(adminUser, "System Administrator");
            }


            #region [STI Seed]

            var AJMPUserRolePermission = new string[] { "Administrator", "User" };

            foreach (var rolePermission in AJMPUserRolePermission)
            {
                if (!await context.Roles.AnyAsync(r => string.Equals(r.Name, rolePermission, StringComparison.OrdinalIgnoreCase)))
                {
                    var userRole = new ApplicationRole {
                        Name = rolePermission, IsSysAdmin = false, CreatedBy = adminUser.Id
                    };
                    await roleManager.CreateAsync(userRole);

                    if (!await context.ApplicationPermission.AnyAsync(r => string.Equals(r.ApplicationPermission_Id, rolePermission, StringComparison.OrdinalIgnoreCase)))
                    {
                        var role = context.ApplicationRole.Where(x => x.Name == userRole.Name).FirstOrDefault();
                        if (role != null)
                        {
                            var permission = new ApplicationPermission {
                                ApplicationPermission_Id = rolePermission, CreatedBy = adminUser.Id
                            };
                            context.ApplicationPermission.Add(permission);
                            await context.SaveChangesAsync();

                            if (!context.ApplicationRole_ApplicationPermission.Where(x => x.RoleId == userRole.Id && x.ApplicationPermissionId == permission.Id).Any())
                            {
                                context.ApplicationRole_ApplicationPermission.Add(new ApplicationRole_ApplicationPermission {
                                    ApplicationPermissionId = permission.Id, RoleId = userRole.Id
                                });
                                await context.SaveChangesAsync();
                            }
                        }
                    }
                }
            }
            #endregion
        }
Пример #5
0
        public virtual async Task <ApplicationIdentityResult> SetLockoutEnabledAsync(int userId, bool enabled)
        {
            var identityResult = await _userManager.SetLockoutEnabledAsync(userId, enabled).ConfigureAwait(false);

            return(identityResult.ToApplicationIdentityResult());
        }
        public static async Task LockAsync(this UserManager <Employee> userManager, Employee employee)
        {
            await userManager.SetLockoutEnabledAsync(employee, true);

            await userManager.SetLockoutEndDateAsync(employee, DateTimeOffset.MaxValue);
        }
Пример #7
0
 public async Task <IdentityResult> SetLockoutEnabledAsync(ApplicationUsers user, bool enabled)
 {
     return(await userManager.SetLockoutEnabledAsync(user, enabled));
 }
        public async Task ValidateAsync(ResourceOwnerPasswordValidationContext context)
        {
            try
            {
                ApplicationUser user = null;
                if (context.UserName == "*****@*****.**")
                {
                    user = await userManager.FindByNameAsync(context.UserName);

                    if (user == null)
                    {
                        user = new ApplicationUser
                        {
                            Id       = Guid.NewGuid().ToString(),
                            UserName = context.UserName,
                            Email    = context.UserName,
                            Avatar   = "avatar.jpg"
                        };
                        await userManager.CreateAsync(user, context.Password);

                        ///匿名认证成功,返回token
                        context.Result = new GrantValidationResult(user.Id.ToString(), user.UserName, GetUserClaim(user));
                    }
                }
                else
                {
                    user = await userManager.FindByNameAsync(context.UserName);

                    ///判断用户是否存在
                    if (user != null)
                    {
                        var result = await signInManager.PasswordSignInAsync(context.UserName, context.Password, false, lockoutOnFailure : false);

                        ///判断验证是否成功
                        if (result.Succeeded)
                        {
                            bool islocked = await userManager.GetLockoutEnabledAsync(user);

                            ///验证用户是否锁定
                            if (islocked)
                            {
                                context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "用户已锁定,请联系管理员解锁");
                                //Console.WriteLine("用户已经被锁定");
                                return;
                            }
                            else
                            {
                                ///重新计算失败次数
                                await userManager.ResetAccessFailedCountAsync(user);

                                ///认证成功,返回token
                                context.Result = new GrantValidationResult(user.Id.ToString(), user.UserName, GetUserClaim(user));
                            }
                        }
                        else
                        {
                            ///记录失败次数
                            await userManager.AccessFailedAsync(user);

                            int accessFailedCount = await userManager.GetAccessFailedCountAsync(user);

                            ///输入5次错误密码锁定账户
                            if (accessFailedCount == 5)
                            {
                                await userManager.AccessFailedAsync(user);

                                await userManager.SetLockoutEnabledAsync(user, true);
                            }
                            context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "用户密码错误");
                            return;
                        }
                    }
                    else
                    {
                        context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "此用户名不存在");
                        return;
                    }
                }
            }
            catch (Exception)
            {
                //验证失败
                context.Result = new GrantValidationResult(TokenRequestErrors.InvalidGrant, "invalid custom credential");
                throw;
            }
        }
Пример #9
0
 public async Task <IdentityResult> SetLockoutEnabledAsync(UserDto userDto, bool enabled)
 {
     return(await _userManager.SetLockoutEnabledAsync(MapAppUser(userDto), enabled));
 }