Jak zmienic role użytkownikowi w Asp.net

komentarz 1 lipca 2019 przez Mystletainn Nowicjusz (200 p.)

Korzystasz z IdentityDbContext? Do ustawiania ról służy role manager. Tutaj nie widzę nic co by miało odnosić się do ról.

UserStore czy UserManager wydaje mi się, że lepiej było by dodać przez wstrzyknięcie, niż tworzenie w ten sposób nowych instancji. Jak możesz to podrzuć resztę controllera, dbcontext, klasę usera i klasę startup.

komentarz 1 lipca 2019 przez Michał_Warmuz Mądrala (5,830 p.)
edycja 1 lipca 2019 przez Michał_Warmuz

wiesz co to juz naprawiłem wystarczyło do bazy w kolumnie dodać applicationrole ale nie wiem czemu wysyakuje mi ze rola 2 nie istnieje gdy wybieram z listy inna role niz user

           private ApplicationSignInManager _signInManager;
        private ApplicationUserManager _userManager;
        private ApplicationRoleManager _roleManager;

        public AccountController()
        {
        }

        public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, ApplicationRoleManager roleManager )
        {
            UserManager = userManager;
            SignInManager = signInManager;
            RoleManager = roleManager;
        }

        public ApplicationSignInManager SignInManager
        {
            get
            {
                return _signInManager ?? HttpContext.GetOwinContext().Get<ApplicationSignInManager>();
            }
            private set 
            { 
                _signInManager = value; 
            }
        }


        public ApplicationRoleManager RoleManager
        {
            get
            {
                return _roleManager ?? HttpContext.GetOwinContext().Get<ApplicationRoleManager>();
            }
            private set
            {
                _roleManager = value;
            }
        }     

[HttpGet]
        public ActionResult Edit(string email)
        {
            

            List<SelectListItem> roles = new List<SelectListItem>();


            

            foreach (var item in RoleManager.Roles)
            {
                roles.Add(new SelectListItem { Value = item.Id, Text = item.Name});
            }

            ViewBag.List = roles;



            ApplicationUser appUser = new ApplicationUser();
            appUser = UserManager.FindByEmail(email);
            UserEdit user = new UserEdit();
            user.UserName = appUser.UserName;
            user.City = appUser.City;
            user.Email = appUser.Email;
            user.Address = appUser.Adress;
            user.Phone = appUser.PhoneNumber;


            return View(user);
        }

        [HttpPost]
        public  ActionResult Edit(UserEdit model)
        {

            if (!ModelState.IsValid)
            {
                return View(model);
            }
            var store = new UserStore<ApplicationUser>(new ApplicationDbContext());
            var manager = new UserManager<ApplicationUser>(store);
            var currentUser = manager.FindByEmail(model.Email);
            currentUser.Email = model.Email;
            currentUser.UserName = model.UserName;
            currentUser.PhoneNumber = model.Phone;
            currentUser.Adress = model.Address;
            currentUser.City = model.City;
            UserManager.AddToRole(currentUser.Id, model.RoleName);
            manager.Update(currentUser);
            var ctx = store.Context;
            ctx.SaveChanges();

            return RedirectToAction("Index", "Home");



        }

    }

using System;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.Owin;
using Microsoft.Owin;
using Microsoft.Owin.Security.Cookies;
using Microsoft.Owin.Security.Google;
using Owin;
using WebApplication47.Models;

namespace WebApplication47
{
    public partial class Startup
    {
        // Aby uzyskać więcej informacji o konfigurowaniu uwierzytelniania, odwiedź stronę https://go.microsoft.com/fwlink/?LinkId=301864
        public void ConfigureAuth(IAppBuilder app)
        {
            // Skonfiguruj kontekst bazy danych, menedżera użytkowników i menedżera logowania, aby używać jednego wystąpienia na żądanie
            app.CreatePerOwinContext(ApplicationDbContext.Create);
            app.CreatePerOwinContext<ApplicationUserManager>(ApplicationUserManager.Create);
            app.CreatePerOwinContext<ApplicationSignInManager>(ApplicationSignInManager.Create);
            app.CreatePerOwinContext<ApplicationRoleManager>(ApplicationRoleManager.Create);

            // Zezwalaj aplikacji na przechowywanie w pliku cookie informacji o zalogowanym użytkowniku
            // oraz na tymczasowe przechowywanie w pliku cookie informacji o użytkowniku logującym się przy użyciu dostawcy logowania innego producenta
            // Konfiguruj plik cookie logowania
            app.UseCookieAuthentication(new CookieAuthenticationOptions
            {
                AuthenticationType = DefaultAuthenticationTypes.ApplicationCookie,
                LoginPath = new PathString("/Account/Login"),
                Provider = new CookieAuthenticationProvider
                {
                    // Umożliwia aplikacji weryfikowanie znacznika zabezpieczeń podczas logowania się użytkownika.
                    // Jest to funkcja zabezpieczeń używana w przypadku zmiany hasła lub dodawania logowania zewnętrznego do konta.  
                    OnValidateIdentity = SecurityStampValidator.OnValidateIdentity<ApplicationUserManager, ApplicationUser>(
                        validateInterval: TimeSpan.FromMinutes(30),
                        regenerateIdentity: (manager, user) => user.GenerateUserIdentityAsync(manager))
                }
            });            
            app.UseExternalSignInCookie(DefaultAuthenticationTypes.ExternalCookie);

            // Umożliwia aplikacji tymczasowe przechowywanie informacji o użytkownikach, gdy używają drugiego etapu w procesie uwierzytelniania dwuetapowego.
            app.UseTwoFactorSignInCookie(DefaultAuthenticationTypes.TwoFactorCookie, TimeSpan.FromMinutes(5));

            // Umożliwia aplikacji zapamiętanie drugiego etapu uwierzytelniania logowania, takiego jak numer telefonu lub adres e-mail.
            // Jeśli zaznaczysz tę opcję, drugi etap weryfikacji w procesie logowania zostanie zapamiętany na urządzeniu, na którym się zalogowano.
            // Ta opcja działa podobnie do opcji RememberMe podczas logowania.
            app.UseTwoFactorRememberBrowserCookie(DefaultAuthenticationTypes.TwoFactorRememberBrowserCookie);

            // Usuń znaczniki komentarza z poniższych wierszy, aby włączyć logowanie przy użyciu innych dostawców logowania
            //app.UseMicrosoftAccountAuthentication(
            //    clientId: "",
            //    clientSecret: "");

            //app.UseTwitterAuthentication(
            //   consumerKey: "",
            //   consumerSecret: "");

            //app.UseFacebookAuthentication(
            //   appId: "",
            //   appSecret: "");

            //app.UseGoogleAuthentication(new GoogleOAuth2AuthenticationOptions()
            //{
            //    ClientId = "",
            //    ClientSecret = ""
            //});
        }
    }
}

using System.Data.Entity;
using System.Security.Claims;
using System.Threading.Tasks;
using Microsoft.AspNet.Identity;
using Microsoft.AspNet.Identity.EntityFramework;

namespace WebApplication47.Models
{
    // Możesz dodać dane profilu dla użytkownika, dodając więcej właściwości do klasy ApplicationUser. Odwiedź stronę https://go.microsoft.com/fwlink/?LinkID=317594, aby dowiedzieć się więcej.
    public class ApplicationUser : IdentityUser
    {

        public string City { get; set; }
        public string Adress { get; set; }
        public async Task<ClaimsIdentity> GenerateUserIdentityAsync(UserManager<ApplicationUser> manager)
        {
            
            // Element authenticationType musi pasować do elementu zdefiniowanego w elemencie CookieAuthenticationOptions.AuthenticationType
            var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);
            // Dodaj tutaj niestandardowe oświadczenia użytkownika
            return userIdentity;
        }
    }
    
    public class ApplicationRole : IdentityRole
    {
        public ApplicationRole() : base() { }

        public ApplicationRole(string roleName) : base(roleName) { }
    }

    public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
    {
        public ApplicationDbContext()
            : base("DefaultConnection", throwIfV1Schema: false)
        {
        }

        public static ApplicationDbContext Create()
        {
            return new ApplicationDbContext();
        }
    }
}

komentarz 1 lipca 2019 przez Mystletainn Nowicjusz (200 p.)

Hmm... niestety nie będę w stanie pomóc. Konfigurowałem logowanie za pomocą ról i użytkownik, ale to w .net core. Tam to się ograniczało do stworzenia DbContext, utworzenie klasu user i rzucenie migracji za pomocą EntityFramework. Sam EF już tak naprawdę tworzył tabele, m.in. taką z rolami, i można było tworzyć nowe role, oraz przypisywać je w kolejnej tabeli. Ponieważ to działa tak, że masz tabelę userów, masz tabelę ról i 3cią tabelę gdzie daną rolę łączysz z danym userem.

Zastanawiam się

           private ApplicationSignInManager _signInManager;

        private ApplicationUserManager _userManager;

        private ApplicationRoleManager _roleManager;



        public AccountController()

        {

        }



        public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, ApplicationRoleManager roleManager )

        {

            UserManager = userManager;

            SignInManager = signInManager;

            RoleManager = roleManager;

        }

Tworzysz np. prywatne pole _signInManager, po czym w konstruktorze robisz wstrzyknięcie ApplicationSignInManager signInManager i przypisujesz to do kolejnej propercji i tam dopiero do prywatnej zmiennej... trochę się szczerze pogubiłem. :)

Ja robię to tak (w .net core, ale to chyba nie ma różnicy)

private readonly SignInManager<IdentityUser> _signInManager;

public AccountController(SignInManager<IdentityUser> signInManager)
{
    _signInManager = signInManager;
}