Beispiel #1
0
        // GET: Users/Edit/5
        public async Task <IActionResult> Edit(string id)
        {
            if (id == null)
            {
                return(NotFound());
            }

            var user = await _context.ApplicationUser.FindAsync(id);

            if (user == null)
            {
                return(NotFound());
            }

            var rollUser = new RoleUserVM();

            rollUser.AppUser = user;

            rollUser.AllRoles = _roleManager.Roles.Select(x => x.Name).ToList();

            var userRoles = await _userManager.GetRolesAsync(user);

            rollUser.UserRoles = userRoles.Select(x => x).ToList();

            return(View(rollUser));
        }
Beispiel #2
0
        public async Task <IActionResult> Edit(string id, RoleUserVM submitUser)
        {
            if (id != submitUser.AppUser.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    var dbUser = await _context.ApplicationUser.FirstOrDefaultAsync(m => m.Id == id);

                    if (dbUser == null)
                    {
                        return(NotFound());
                    }
                    dbUser.Email            = submitUser.AppUser.Email;
                    dbUser.LastName         = submitUser.AppUser.LastName;
                    dbUser.FirstName        = submitUser.AppUser.FirstName;
                    dbUser.Position         = submitUser.AppUser.Position;
                    dbUser.DuesPaid         = submitUser.AppUser.DuesPaid;
                    dbUser.MeetingsAttended = submitUser.AppUser.MeetingsAttended;
                    _context.Update(dbUser);

                    //Handle Roles

                    //Remove all roles
                    await _userManager.RemoveFromRolesAsync(dbUser, await _userManager.GetRolesAsync(dbUser));

                    //Add new roles that were checked
                    var roles = Request.Form["CheckRoles"].ToString().Split(",");
                    foreach (var role in roles)
                    {
                        _userManager.AddToRoleAsync(submitUser.AppUser, role).GetAwaiter().GetResult();
                    }

                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!UserExists(submitUser.AppUser.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(submitUser));
        }
Beispiel #3
0
        public async Task <IActionResult> Create(RoleUserVM submitUser)
        {
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser
                {
                    UserName       = submitUser.AppUser.Email,
                    Email          = submitUser.AppUser.Email,
                    EmailConfirmed = true,
                    FirstName      = submitUser.AppUser.FirstName,
                    LastName       = submitUser.AppUser.LastName,
                    State          = submitUser.AppUser.State,
                    City           = submitUser.AppUser.City,
                    StreetAddress  = submitUser.AppUser.StreetAddress,
                    ZipCode        = submitUser.AppUser.ZipCode
                };
                string password = Request.Form["Password"].ToString();
                var    result   = await _userManager.CreateAsync(user, password);

                if (result.Succeeded)
                {
                    //Go get the user who was just created. This is needed because the DB generated an ID for the user
                    var userFromDB = await _userManager.FindByEmailAsync(submitUser.AppUser.Email);

                    if (userFromDB == null)
                    {
                        return(NotFound());
                    }

                    //Add new roles that were checked
                    var roles = Request.Form["CheckRoles"].ToString().Split(",");
                    foreach (var role in roles)
                    {
                        _userManager.AddToRoleAsync(userFromDB, role).GetAwaiter().GetResult();
                    }

                    await _context.SaveChangesAsync();

                    return(RedirectToAction(nameof(Index)));
                }
                foreach (var error in result.Errors)
                {
                    ModelState.AddModelError(string.Empty, error.Description);
                }
            }
            // If we got this far, something failed, redisplay form
            return(RedirectToAction(nameof(Index)));
        }
Beispiel #4
0
        public async Task <IActionResult> Assign(RoleUserVM roleUser)
        {
            var user        = _db.ApplicationUsers.FirstOrDefault(c => c.Id == roleUser.UserId);
            var isCheckRole = await _userManager.IsInRoleAsync(user, roleUser.RoleId);

            if (isCheckRole)
            {
                ViewBag.msg        = "This user already assign.";
                ViewData["UserId"] = new SelectList(_db.ApplicationUsers.Where(c => c.LockoutEnd < DateTime.Now || c.LockoutEnd == null).ToList(), "Id", "UserName");
                ViewData["RoleId"] = new SelectList(_roleManager.Roles.ToList(), "Name", "Name");
                return(View());
            }
            var role = await _userManager.AddToRoleAsync(user, roleUser.RoleId);

            if (role.Succeeded)
            {
                TempData["save"] = "User Role assign";
                return(RedirectToAction(nameof(Index)));
            }
            return(View());
        }