Création de rôles dans Asp.net Identity MVC 5

Il existe très peu de documentation sur l'utilisation du nouveau framework Asp.net Identity Security.

J'ai rassemblé ce que je pouvais pour essayer de créer un nouveau rôle et y ajouter un utilisateur. J'ai essayé ce qui suit: Ajouter un rôle dans ASP.NET Identity

qui semble avoir obtenu les informations de ce blog: créer une application simple à faire avec l'identité asp.net et associer les utilisateurs à des tâches

J'ai ajouté le code à un initialiseur de base de données qui est exécuté chaque fois que le modèle change. Il échoue sur la RoleExistsfonction avec l'erreur suivante:

System.InvalidOperationException s'est produite dans mscorlib.dll Le type d'entité IdentityRole ne fait pas partie du modèle pour le contexte actuel.

protected override void Seed (MyContext context)
{
    var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context)); 
    var RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));

    // Create Admin Role
    string roleName = "Admins";
    IdentityResult roleResult;

    // Check to see if Role Exists, if not create it
    if (!RoleManager.RoleExists(roleName))
    {
        roleResult = RoleManager.Create(new IdentityRole(roleName));
    }
}

Toute aide est appréciée.

Vérifiez que vous avez la signature suivante de votre MyContextclasse

public class MyContext : IdentityDbContext<MyUser>

Ou

public class MyContext : IdentityDbContext

Le code fonctionne pour moi, sans aucune modification !!!

Et c'est parti:

var roleManager = new RoleManager<Microsoft.AspNet.Identity.EntityFramework.IdentityRole>(new RoleStore<IdentityRole>(new ApplicationDbContext()));


   if(!roleManager.RoleExists("ROLE NAME"))
   {
      var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
      role.Name = "ROLE NAME";
      roleManager.Create(role);

    }

Voici l'article complet décrivant comment créer un rôle, modifier des rôles, supprimer des rôles et gérer des rôles à l'aide d'ASP.NET Identity. Cela contient également l'interface utilisateur, les méthodes du contrôleur, etc.

http://www.dotnetfunda.com/articles/show/2898/working-with-roles-in-aspnet-identity-for-mvc

J'espère que cette aide

Merci

En ASP.NET 5 rc1-final, j'ai fait ce qui suit:

Créé ApplicationRoleManager(de la même manière qu'il est ApplicationUsercréé par le modèle)

public class ApplicationRoleManager : RoleManager<IdentityRole>
{
    public ApplicationRoleManager(
        IRoleStore<IdentityRole> store,
        IEnumerable<IRoleValidator<IdentityRole>> roleValidators,
        ILookupNormalizer keyNormalizer,
        IdentityErrorDescriber errors,
        ILogger<RoleManager<IdentityRole>> logger,
        IHttpContextAccessor contextAccessor)
        : base(store, roleValidators, keyNormalizer, errors, logger, contextAccessor)
    {
    }
}

Pour ConfigureServicesen Startup.cs, je l' ai ajouté comme roleManager

services.
    .AddIdentity<ApplicationUser, IdentityRole>()
    .AddRoleManager<ApplicationRoleManager>();

Pour créer de nouveaux rôles, appelez les éléments Configuresuivants:

public static class RoleHelper
{
    private static async Task EnsureRoleCreated(RoleManager<IdentityRole> roleManager, string roleName)
    {
        if (!await roleManager.RoleExistsAsync(roleName))
        {
            await roleManager.CreateAsync(new IdentityRole(roleName));
        }
    }
    public static async Task EnsureRolesCreated(this RoleManager<IdentityRole> roleManager)
    {
        // add all roles, that should be in database, here
        await EnsureRoleCreated(roleManager, "Developer");
    }
}

public async void Configure(..., RoleManager<IdentityRole> roleManager, ...)
{
     ...
     await roleManager.EnsureRolesCreated();
     ...
}

Désormais, les règles peuvent être attribuées à l'utilisateur

await _userManager.AddToRoleAsync(await _userManager.FindByIdAsync(User.GetUserId()), "Developer");

Ou utilisé dans l' Authorizeattribut

[Authorize(Roles = "Developer")]
public class DeveloperController : Controller
{
}

Comme amélioration du code Peters ci-dessus, vous pouvez utiliser ceci:

   var roleManager = new RoleManager<Microsoft.AspNet.Identity.EntityFramework.IdentityRole>(new RoleStore<IdentityRole>(new ApplicationDbContext()));

   if (!roleManager.RoleExists("Member"))
            roleManager.Create(new IdentityRole("Member"));

Mon application se bloquait au démarrage lorsque j'ai utilisé les exemples de code de Peter Stulinski et Dave Gordon avec EF 6.0. J'ai changé:

var roleManager = new RoleManager<Microsoft.AspNet.Identity.EntityFramework.IdentityRole>(new RoleStore<IdentityRole>(new ApplicationDbContext()));

à

var roleManager = new RoleManager<Microsoft.AspNet.Identity.EntityFramework.IdentityRole>(new RoleStore<IdentityRole>(**context**));

Ce qui est logique lorsque, dans la méthode seed, vous ne voulez pas instancier une autre instance du ApplicationDBContext. Cela aurait pu être aggravé par le fait que j'avais Database.SetInitializer<ApplicationDbContext>(new ApplicationDbInitializer());dans le constructeur deApplicationDbContext

Modèle de vue des rôles

public class RoleViewModel
{
    public string Id { get; set; }
    [Required(AllowEmptyStrings = false)]
    [Display(Name = "RoleName")]
    public string Name { get; set; }
}

Méthode du contrôleur

    [HttpPost]
    public async Task<ActionResult> Create(RoleViewModel roleViewModel)
    {
       if (ModelState.IsValid)
       {
           var role = new IdentityRole(roleViewModel.Name);
           var roleresult = await RoleManager.CreateAsync(role);
           if (!roleresult.Succeeded)
           {
               ModelState.AddModelError("", roleresult.Errors.First());
               return View();
           }
           return RedirectToAction("some_action");
       }
       return View();
    }

Je voulais partager une autre solution pour ajouter des rôles:

<h2>Create Role</h2>

@using (Html.BeginForm())
{
@Html.AntiForgeryToken()
@Html.ValidationSummary(true)
<span class="label label-primary">Role name:</span>
<p>
    @Html.TextBox("RoleName", null, new { @class = "form-control input-lg" })
</p>
<input type="submit" value="Save" class="btn btn-primary" />
}

Manette:

    [HttpGet]
    public ActionResult AdminView()
    {
        return View();
    }

    [HttpPost]
    public ActionResult AdminView(FormCollection collection)
    {
        var roleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(new ApplicationDbContext()));

        if (roleManager.RoleExists(collection["RoleName"]) == false)
        {
            Guid guid = Guid.NewGuid();
            roleManager.Create(new IdentityRole() { Id = guid.ToString(), Name = collection["RoleName"] });
        }
        return View();
    }

Si vous utilisez le modèle par défaut qui est créé lorsque vous sélectionnez une nouvelle application Web ASP.net et des comptes d'utilisateurs individuels sélectionnés comme authentification et que vous essayez de créer des utilisateurs avec des rôles, voici la solution. Dans la méthode d'enregistrement du contrôleur de compte qui est appelée à l'aide de [HttpPost], ajoutez les lignes suivantes dans if condition.

en utilisant Microsoft.AspNet.Identity.EntityFramework;

var user = new ApplicationUser { UserName = model.Email, Email = model.Email };

var result = await UserManager.CreateAsync(user, model.Password);

if (result.Succeeded)
{
  var roleStore = new RoleStore<IdentityRole>(new ApplicationDbContext());
  var roleManager = new RoleManager<IdentityRole>(roleStore);
  if(!await roleManager.RoleExistsAsync("YourRoleName"))
     await roleManager.CreateAsync(new IdentityRole("YourRoleName"));

  await UserManager.AddToRoleAsync(user.Id, "YourRoleName");
  await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
  return RedirectToAction("Index", "Home");
}

Cela créera d'abord créer un rôle dans votre base de données, puis ajoutera l'utilisateur nouvellement créé à ce rôle.

    public static void createUserRole(string roleName)
    {
        if (!System.Web.Security.Roles.RoleExists(roleName))
        {
            System.Web.Security.Roles.CreateRole(roleName);
        }
    }

la méthode que j'utilise pour créer des rôles est ci-dessous, leur attribution aux utilisateurs dans le code est également répertoriée. le code ci-dessous se trouve dans "configuration.cs" dans le dossier migrations.

string [] roleNames = { "role1", "role2", "role3" };
var RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));

                IdentityResult roleResult;
                foreach(var roleName in roleNames)
                {
                    if(!RoleManager.RoleExists(roleName))
                    {
                        roleResult = RoleManager.Create(new IdentityRole(roleName));
                    }
                }
                var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
                UserManager.AddToRole("user", "role1");
                UserManager.AddToRole("user", "role2");
                context.SaveChanges();