ASP .NET Core - Criando e atribuindo Roles - III

 Neste artigo eu vou mostrar como criar e atribuir roles a usuários em uma aplicação ASP .NET Core MVC.

Continuando a segunda parte do artigo vamos agora atribuir os perfis criados aos usuários e aplicar a autenticação baseada em Roles para testar se nossa implementação realmente funcionou.

A página de registro de um novo usuário agora exibe os perfis criados. Para atribuir um perfil ao usuário basta selecionar o perfil e clicar no botão Register.

Recursos usados:

Atribuindo um perfil de usuário

Para poder exibir atribuir um perfil selecionado ao usuário temos que alterar o código da classe AccountController.

Vamos alterar o método Register (HttpPost) que será acionando quando o usuário clicar no botão Register da página de registro.

Inclua no método Register o código destacado em azul mostrado abaixo:

        [HttpPost]
        [AllowAnonymous]
        [ValidateAntiForgeryToken]
        public async Task<IActionResult> Register(RegisterViewModel model, string returnUrl = null)
        {
            ViewData["ReturnUrl"] = returnUrl;
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                var result = await _userManager.CreateAsync(user, model.Password);
                if (result.Succeeded)
                {
                    _logger.LogInformation("User created a new account with password.");

                    var code = await _userManager.GenerateEmailConfirmationTokenAsync(user);
                    var callbackUrl = Url.EmailConfirmationLink(user.Id, code, Request.Scheme);
                    await _emailSender.SendEmailConfirmationAsync(model.Email, callbackUrl);

                    //-------------------atribuir role ao user------------------------------
                    var applicationRole = await _roleManager.FindByNameAsync(model.Role);
                    if (applicationRole != null)
                    {
                        IdentityResult roleResult = await _userManager.AddToRoleAsync(user, applicationRole.Name);
                    }
                    //-------------------atribuir role ao user------------------------------

                    await _signInManager.SignInAsync(user, isPersistent: false);
                    _logger.LogInformation("User created a new account with password.");
                    return RedirectToLocal(returnUrl);
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }

No código incluído estamos localizando o nome do perfil selecionado usando o método FindByNameAsync e a seguir verificando se ele não é nulo.

Depois estamos usando o método AddToRoleAsync() para atribuir ao usuário o perfil selecionado.

Para que o código acima funcione temos que incluir no construtor da classe AccountController uma instância da classe RoleManager.

Abaixo vemos o código alterado:

    [Authorize]
    [Route("[controller]/[action]")]
    public class AccountController : Controller
    {
        private readonly UserManager<ApplicationUser> _userManager;
        private readonly SignInManager<ApplicationUser> _signInManager;
        private readonly IEmailSender _emailSender;
        private readonly ILogger _logger;
        private readonly RoleManager<IdentityRole> _roleManager;

        public AccountController(
            UserManager<ApplicationUser> userManager,
            SignInManager<ApplicationUser> signInManager,
            IEmailSender emailSender,
            RoleManager<IdentityRole> roleManager,
            ILogger<AccountController> logger)
        {
            _userManager = userManager;
            _signInManager = signInManager;
            _emailSender = emailSender;
            _roleManager = roleManager;
            _logger = logger;
        }
        ....
}

 

Executando o projeto e registrando um novo usuário:

Podemos verificar na tabela AspNetUserRoles o Id do usuário e o id do perfil atribuído:

Para fazer a prova dos nove vamos aplicar a autenticação baseada em Roles usando o atributo Authorize.

Autenticação baseada em roles

Agora que temos usuários registrados e perfis atribuídos podemos usar o atributo Authorize para permitir o acesso a um recurso usando o perfil do usuário.

Para fazer isso basta definir em um controlador ou método Action o atributo Authorize e especificar o perfil que terá acesso usando Roles :  Authorize(Roles="Perfil1, Perfil2,...")

Como exemplo vamos definir o atributo Authorize no método Action Contact do controlador HomeController definindo que somente os usuários que tem o perfil  'Admin' terão acesso a essa Action: 

        [Authorize(Roles = "Admin")]
        public IActionResult Contact()
        {
            ViewData["Message"] = "Página de contato do Admin.";
            return View();
        }

Nossa aplicação possui dois usuários registrados:

  1. admin@admin.com.br  com perfil Admin
  2. teste@teste.com.br  com perfil User   

Agora se você executar a aplicação novamente e se logar como usuário teste@teste.com.br ao tentar acessar a Action Contact irá obter o seguinte resultado:

Como o usuário não pertence ao perfil Admin ele não terá acesso ao recurso.

Agora se logando como usuário admin@admin.com.br e acessando a Action Contact teremos o resultado abaixo:

Como o usuário possui o perfil Admin ele tem acesso ao recurso.

Dessa forma a atribuição de perfis aos usuários esta funcionando corretamente.

Pegue o projeto aqui :  AspCore_Roles.zip

(Disse Jesus)"Mas a hora vem, e agora é, em que os verdadeiros adoradores adorarão o Pai em espírito e em verdade; porque o Pai procura a tais que assim o adorem."
 João 4:23
 
Veja os Destaques e novidades do SUPER DVD Visual Basic (sempre atualizado) : clique e confira !

Quer migrar para o VB .NET ?

Quer aprender C# ??

Quer aprender os conceitos da Programação Orientada a objetos ?

Quer aprender o gerar relatórios com o ReportViewer no VS 2013 ?

  Gostou ?   Compartilhe no Facebook   Compartilhe no Twitter

Referências:

José Carlos Macoratti