Como Criar, Ler, Atualizar e Apagar Usuários com o ASP.NET Core Identity

using Microsoft.AspNetCore.Identity;
using Microsoft.AspNetCore.Mvc;
using PoupaTempoDigital.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Logging;


namespace PoupaTempoDigital.Controllers
{
    public class AdminController : Controller
    {
        private readonly UserManager<AppUser> _userManager;
        private readonly ILogger<AdminController> _logger;
        private readonly RoleManager<AppRole> _roleManager;
        private IPasswordHasher<AppUser> _passwordHasher;
        public AdminController(
            UserManager<AppUser> userManager
            , ILogger<AdminController> logger
            , RoleManager<AppRole> roleManager
            , IPasswordHasher<AppUser> passwordHash
            )
        {
            _userManager = userManager;
            _logger = logger;
            _roleManager = roleManager;
            _passwordHasher = passwordHash;
        }
        public IActionResult Index()
        {
            List<AppUser> novaListaUsuarios = new List<AppUser>();
            var todosUsuarios = (from user in _userManager.Users
                                 select new AppUser
                                 {
                                     Id = user.Id,
                                     FirstName = user.FirstName,
                                     LastName = user.LastName,
                                     PhoneNumber = user.PhoneNumber,
                                     Email = user.Email

                                 });

            ViewBag.DataSource = todosUsuarios;
            return View();

        }

        // GET: Pessoas/Delete/5
        public async Task<IActionResult> Delete(int? id)
        {
            if (id == null)
            {
                return NotFound();
            }

            var usuario = await _userManager.Users.FirstOrDefaultAsync(m => m.Id == id);
            //ViewBag.DataSource =  _userManager.Users;
            if (usuario == null)
            {
                return NotFound();
            }

            return View(usuario);
        }


        [HttpPost, ActionName("Delete")]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> DeleteConfirmed(int id)
        {
            AppUser user = await _userManager.FindByIdAsync(id.ToString());
            if (user != null)
            {
                IdentityResult result = await _userManager.DeleteAsync(user);
                if (result.Succeeded)
                { return RedirectToAction(nameof(Index)); }
                else
                { Errors(result); }
            }
            else
            { 
               ModelState.AddModelError("", "Usuário não Encontado"); 
            }
            //return View("Index", _userManager.Users);
            //ViewBag.DataSource = _userManager.Users;
            return RedirectToAction(nameof(Index));
        }

        public async Task<IActionResult> Update(int Id)
        {
            AppUser user = await _userManager.FindByIdAsync(Id.ToString());
            if (user != null)
                return View(user);
            else
                return RedirectToAction("Index");
        }

        [HttpPost]
        public async Task<IActionResult> Update(int Id, string email, string password, string FirstName, string LastName, string PhoneNumber)
        {
            AppUser user = await _userManager.FindByIdAsync(Id.ToString());
            if (user != null)
            {
                if (!string.IsNullOrEmpty(email))
                    user.Email = email;
                else
                    ModelState.AddModelError("", "O E-mail não pode ser vazio");

                if (!string.IsNullOrEmpty(FirstName))
                    user.FirstName = FirstName;
                else
                    ModelState.AddModelError("", "O Nome não pode ser vazio");

                if (!string.IsNullOrEmpty(LastName))
                    user.LastName = LastName;
                else
                    ModelState.AddModelError("", "O Sobrenome não pode ser vazio");

                if (!string.IsNullOrEmpty(PhoneNumber))
                    user.PhoneNumber = PhoneNumber;
                else
                    ModelState.AddModelError("", "O telefone do WhatsApp não pode ser vazio");


                if (!string.IsNullOrEmpty(password))
                    user.PasswordHash = _passwordHasher.HashPassword(user, password);
                else
                    ModelState.AddModelError("", "A senha não pode ser vazia");

                if (!string.IsNullOrEmpty(email) && !string.IsNullOrEmpty(password))
                {
                    IdentityResult result = await _userManager.UpdateAsync(user);
                    if (result.Succeeded)
                        return RedirectToAction("Index");
                    else
                        Errors(result);
                }
            }
            else
                ModelState.AddModelError("", "Usuário não encontrado");
            return View(user);
        }

        private void Errors(IdentityResult result)
        {
            foreach (IdentityError error in result.Errors)
                ModelState.AddModelError("", error.Description);
        }


        public ViewResult Create() => View();

        [HttpPost]
        public async Task<IActionResult> Create(AppUser user)
        {
            if (ModelState.IsValid)
            {
                var usuario = await _userManager.FindByEmailAsync(user.Email);
                if (usuario != null) //existe usuario
                {
                    ModelState.AddModelError("Email", "Este e-mail já está cadastrado no PoupaTempo. Entre no sistema usando o Acesso, no menu");
                    return View("Create", user);
                }


                AppUser appUser = new AppUser
                {
                    FirstName = user.FirstName,
                    LastName = user.LastName,
                    PhoneNumber = user.PhoneNumber,
                    Email = user.Email,
                    Interesse = 4, //todo definido um valor fixo arbitrário, deveria ser  user.Interesse,
                    Password = user.Password
                };
                appUser.UserName = appUser.Email;
                appUser.EmailConfirmed = true;
                //appUser.SecurityStamp = Guid.NewGuid().ToString();
                IdentityResult result = await _userManager.CreateAsync(appUser, user.Password);
                if (result.Succeeded)
                {
                    _logger.LogInformation("O usuário criou uma nova conta com senha.");
                    //cria papéis se ainda não existem
                    //admin
                    if (!await _roleManager.RoleExistsAsync(Papeis.AdminEndUser))
                    {
                        await _roleManager.CreateAsync(new AppRole(Papeis.AdminEndUser));
                    }
                    //cliente
                    if (!await _roleManager.RoleExistsAsync(Papeis.ClienteEndUser))
                    {
                        await _roleManager.CreateAsync(new AppRole(Papeis.ClienteEndUser));
                    }
                    //colaborador
                    if (!await _roleManager.RoleExistsAsync(Papeis.ColaboradorEndUser))
                    {
                        await _roleManager.CreateAsync(new AppRole(Papeis.ColaboradorEndUser));
                    }
                    //cria papel padrao para cada novo inscrito = Cliente
                    await _userManager.AddToRoleAsync(appUser, Papeis.ClienteEndUser);
                }
                else
                {
                    foreach (IdentityError error in result.Errors)
                        ModelState.AddModelError("Erro:", error.Description);
                    return View("Create", user);
                }
                return RedirectToAction("Index");
            }
            return View("Index");
        }
    }
}