web-dev-qa-db-fra.com

Ajouter un utilisateur au rôle Identité ASP.NET

Je sais que la nouvelle adhésion comprend un "fournisseur de rôle simple".

Je ne trouve aucune aide liée à la création d'un utilisateur et à l'attribution d'un rôle lors de la création de l'utilisateur. J'ai ajouté un utilisateur qui a créé les tables sur le DB correctement. Je vois les tables AspNetRoles, AspNetUserRoles et AspNetUsers.

Je souhaite attribuer un rôle de AspNetRoles à un utilisateur dans AspNetUsers dont le ID du rôle/de l'utilisateur doivent être stockés dans AspNetUserRoles.

Je suis coincé dans la partie programmation où et comment le faire lorsque je crée l'utilisateur.

J'ai une liste déroulante pour sélectionner le rôle, mais en utilisant Entity CF avec le nouveau modèle d'identité ASP.NET, je ne suis pas sûr de savoir comment prendre l'ID de la valeur sélectionnée dans la liste déroulante et l'ID utilisateur et attribuer le rôle.

asp.netasp.net-identityasp.net-roles
34
Brad Martin

J'ai trouvé la bonne réponse ici Ajout de rôle dynamique dans le nouveau VS 2013 Identity UserManager

Mais au cas où donner un exemple pour que vous puissiez le vérifier, je vais partager un code par défaut.

Commencez par vous assurer que les rôles sont insérés.

enter image description here

Et deuxième test sur la méthode de registre de l'utilisateur.

[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Register(RegisterViewModel model)
{
    if (ModelState.IsValid)
    {
        var user = new ApplicationUser() { UserName = model.UserName  };

        var result = await UserManager.CreateAsync(user, model.Password);
        if (result.Succeeded)
        {
            var currentUser = UserManager.FindByName(user.UserName); 

            var roleresult = UserManager.AddToRole(currentUser.Id, "Superusers");

            await SignInAsync(user, isPersistent: false);
            return RedirectToAction("Index", "Home");
        }
        else
        {
            AddErrors(result);
        }
    }

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

Enfin, vous devez obtenir les "superutilisateurs" de la liste déroulante des rôles.

62
Developer

J'ai eu le même défi. C’est la solution que j’ai trouvée pour ajouter des utilisateurs aux rôles.

internal class Security
{
    ApplicationDbContext context = new ApplicationDbContext();

    internal void AddUserToRole(string userName, string roleName)
    {
        var UserManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));

        try
        {
            var user = UserManager.FindByName(userName);
            UserManager.AddToRole(user.Id, roleName);
            context.SaveChanges();
        }
        catch
        {
            throw;
        }
    }
}
23
Tarzan

Bien que je sois d’accord avec les autres réponses concernant le RoleManager, je vous conseillerais d’examiner la possibilité de mettre en œuvre l’autorisation via des revendications ( Exprimer des rôles en tant que revendications ).

À partir de .NET Framework 4.5, Windows Identity Foundation (WIF) a été entièrement intégré à .NET Framework.

Dans les applications prenant en charge les revendications, le rôle est exprimé par un type de revendication de rôle qui devrait être disponible dans le jeton. Lorsque la méthode IsInRole () est appelée, une vérification est effectuée pour voir si l'utilisateur actuel a ce rôle.

Le type de revendication de rôle est exprimé à l'aide de l'URI suivant: " http://schemas.Microsoft.com/ws/2008/06/identity/claims/role "

Donc au lieu d'utiliser le RoleManager, vous pouvez "ajouter un utilisateur à un rôle" à partir du UserManager , en effectuant quelque chose comme ceci:

var um = new UserManager();
um.AddClaimAsync(1, new Claim("http://schemas.Microsoft.com/ws/2008/06/identity/claims/role", "administrator"));

Avec les lignes ci-dessus, vous avez ajouté une revendication de rôle avec la valeur "administrateur" à l'utilisateur portant l'id "1" ...

L'autorisation de réclamation, telle que suggérée par MSFT, peut simplifier et augmenter les performances des processus d'authentification et d'autorisation en éliminant certaines requêtes dorsales à chaque autorisation.

En utilisant Claims, vous n’aurez peut-être plus besoin du RoleStore. (AspNetRoles, AspNetUserRoles)

12
MyOwnWay

Cherchez-vous quelque chose comme ça:

RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(new MyDbContext()));
var str = RoleManager.Create(new IdentityRole(roleName));

Vérifiez également identité de l'utilisateur

9
Rahul Tripathi

Vérifiez ce lien: Attribution de rôles aux utilisateurs . Vous pouvez ajouter une étape à votre contrôle CreateUserWIzard et choisir les rôles dans cette étape.

<asp:CreateUserWizard ID="RegisterUserWithRoles" runat="server" 
    ContinueDestinationPageUrl="~/Default.aspx" LoginCreatedUser="False" 
    onactivestepchanged="RegisterUserWithRoles_ActiveStepChanged">
    <WizardSteps>
        <asp:CreateUserWizardStep ID="CreateUserWizardStep1" runat="server">
        </asp:CreateUserWizardStep>
        <asp:WizardStep ID="SpecifyRolesStep" runat="server" AllowReturn="False" 
            StepType="Step" Title="Specify Roles">
            <h3>Choose the role.</h3>
            <asp:CheckBoxList ID="RoleList" runat="server">
            </asp:CheckBoxList>
        </asp:WizardStep>
        <asp:CompleteWizardStep ID="CompleteWizardStep1" runat="server">
        </asp:CompleteWizardStep>
    </WizardSteps>
</asp:CreateUserWizard>

Et dans le code-behind, vous aurez:

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    {
        // Reference the SpecifyRolesStep WizardStep 
        WizardStep SpecifyRolesStep = RegisterUserWithRoles.FindControl("SpecifyRolesStep") as WizardStep;

        // Reference the RoleList CheckBoxList 
        CheckBoxList RoleList = SpecifyRolesStep.FindControl("RoleList") as CheckBoxList;

        // Bind the set of roles to RoleList 
        RoleList.DataSource = Roles.GetAllRoles();
        RoleList.DataBind();
    } 
}
protected void RegisterUserWithRoles_ActiveStepChanged(object sender, EventArgs e)
{
    // Have we JUST reached the Complete step? 
    if (RegisterUserWithRoles.ActiveStep.Title == "Complete")
    {
        // Reference the SpecifyRolesStep WizardStep 
        WizardStep SpecifyRolesStep = RegisterUserWithRoles.FindControl("SpecifyRolesStep") as WizardStep;

        // Reference the RoleList CheckBoxList 
        CheckBoxList RoleList = SpecifyRolesStep.FindControl("RoleList") as CheckBoxList;

        // Add the checked roles to the just-added user 
        foreach (ListItem li in RoleList.Items)
        {
            if (li.Selected)
                Roles.AddUserToRole(RegisterUserWithRoles.UserName, li.Text);
        }
    }
}
2
user3138901

Vous trouverez ci-dessous une implémentation alternative d'une méthode de contrôleur 'créer un utilisateur' utilisant des rôles basés sur des revendications.

Les revendications créées fonctionnent ensuite avec l'attribut Authorize, par exemple. [Autoriser (Roles = "Admin, User. *, User.Create")]

    // POST api/User/Create
    [Route("Create")]
    public async Task<IHttpActionResult> Create([FromBody]CreateUserModel model)
    {
        if (!ModelState.IsValid)
        {
            return BadRequest(ModelState);
        }

        // Generate long password for the user
        var password = System.Web.Security.Membership.GeneratePassword(25, 5);

        // Create the user
        var user = new ApiUser() { UserName = model.UserName };
        var result = await UserManager.CreateAsync(user, password);
        if (!result.Succeeded)
        {
            return GetErrorResult(result);
        }

        // Add roles (permissions) for the user
        foreach (var perm in model.Permissions)
        {
            await UserManager.AddClaimAsync(user.Id, new Claim(ClaimTypes.Role, perm));
        }

        return Ok<object>(new { UserName = user.UserName, Password = password });
    }
2
cwills

Celui-ci fonctionne pour moi. Vous pouvez voir ce code sur AccountController -> Enregistrer

var user = new JobUser { UserName = model.Email, Email = model.Email };
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
    //add this to add role to user
     await UserManager.AddToRoleAsync(user.Id, "Name of your role");
}

mais le nom du rôle doit exister dans votre table AspNetRoles.

0
Just Passing By