public async Task<IActionResult> Editar(ApplicationUser editarUser)
        {
            var user = await GetCurrentUserAsync();
            if (user != null)
            {
                user.DepartamentoId = editarUser.DepartamentoId;
                user.Nome = editarUser.Nome;
                user.Email = editarUser.Email;
                user.PhoneNumber = editarUser.PhoneNumber;

                var roles = await _userManager.GetRolesAsync(user);
                await _userManager.RemoveFromRolesAsync(user, roles);
                await _userManager.AddToRolesAsync(user, editarUser.RoleNames);
                await _userManager.UpdateAsync(user);                
            }
            
            return Redirect();
        }
Beispiel #2
0
        private static async Task CreateAdminUser(IServiceProvider serviceProvider)
        {
            var options = serviceProvider.GetRequiredService<IOptions<IdentityDbContextOptions>>().Value;
            var userManager = serviceProvider.GetRequiredService<UserManager<ApplicationUser>>();
            var roleManager = serviceProvider.GetRequiredService<RoleManager<IdentityRole>>();
            string adminRole = options.AdministratorRole.Trim();

            if (!string.IsNullOrEmpty(options.Roles))
            {
                foreach (var role in options.Roles.Split(','))
                {
                    if (!await roleManager.RoleExistsAsync(role.Trim()))
                    {
                        await roleManager.CreateAsync(new IdentityRole(role.Trim()));
                    }
                }
            }

            if (!await roleManager.RoleExistsAsync(adminRole))
            {
                await roleManager.CreateAsync(new IdentityRole(adminRole));
            }

            var user = await userManager.FindByNameAsync(options.DefaultAdminUserName);
            if (user == null)
            {
                user = new ApplicationUser
                {
                    UserName = options.DefaultAdminUserName,
                    Email = options.DefaultAdminUserName,
                    Nome = "Administrador",
                    DepartamentoId = 2
                };
                await userManager.CreateAsync(user, options.DefaultAdminPassword);
                await userManager.AddToRoleAsync(user, adminRole);
            }
        }
        public async Task<IActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser
                {
                    Nome = model.Nome,
                    UserName = model.Email,
                    Email = model.Email,
                    DepartamentoId = model.Departamento,
                    PhoneNumber = model.PhoneNumber
                };

                var result = await _userManager.CreateAsync(user, model.Password);
                if (result.Succeeded)
                {
                    if (model.Login)
                    {
                        var t1 = _userManager.AddToRolesAsync(user, model.Roles);
                        var t2 = _signInManager.SignInAsync(user, isPersistent: false);
                        await Task.WhenAll(t1, t2);
                    }
                    else
                    {
                        await _userManager.AddToRolesAsync(user, model.Roles);
                        return RedirectToAction(nameof(UtilizadoresController.Index), "Utilizadores");
                    }

                    _logger.LogInformation(3, "User created a new account with password.");
                    return RedirectToAction(nameof(HomeController.Index), "Home");
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return View(model);
        }
        public async Task<IActionResult> ExternalLoginConfirmation(ExternalLoginConfirmationViewModel model, string returnUrl = null)
        {
            if (User.IsSignedIn())
            {
                return RedirectToAction(nameof(ManageController.Index), "Manage");
            }

            if (ModelState.IsValid)
            {
                // Get the information about the user from the external login provider
                var info = await _signInManager.GetExternalLoginInfoAsync();
                if (info == null)
                {
                    return View("ExternalLoginFailure");
                }
                var user = new ApplicationUser { UserName = model.Email, Email = model.Email };
                var result = await _userManager.CreateAsync(user);
                if (result.Succeeded)
                {
                    result = await _userManager.AddLoginAsync(user, info);
                    if (result.Succeeded)
                    {
                        await _signInManager.SignInAsync(user, isPersistent: false);
                        _logger.LogInformation(6, "User created an account using {Name} provider.", info.LoginProvider);
                        return RedirectToLocal(returnUrl);
                    }
                }
                AddErrors(result);
            }

            ViewData["ReturnUrl"] = returnUrl;
            return View(model);
        }