Ajouter L'utilisateur au rôle ASP.NET L'identité

j'ai trouvé la bonne réponse ici Ajout de Rôle de façon dynamique dans la nouvelle VS 2013 Identité UserManager

mais dans le cas de fournir un exemple pour que vous puissiez le vérifier, je vais partager du code par défaut.

assurez-vous D'abord que vous avez des rôles insérés.

et le deuxième test il 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);
}

et enfin vous je dois trouver" Superusers " dans la liste déroulante des rôles.

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;
        }
    }
}

bien que je sois d'accord avec les autres réponses concernant le RoleManager, je conseillerais d'examiner la possibilité de mettre en œuvre L'autorisation par le biais de revendications ( exprimant des rôles en tant que revendications ).

à partir du .net Framework 4.5, Windows Identity Foundation (WIF) a été pleinement intégré dans le .net Framework.

dans les applications tenant compte des revendications, le rôle est exprimé par un type de revendication de rôle qui devrait être disponible en jeton. Quand la méthode IsInRole () est appelée, il y a une vérification faite pour voir si l'utilisateur courant a ce rôle.

le type de revendication de rôle est exprimé en utilisant L'URI suivant:: " http://schemas.microsoft.com/ws/2008/06/identity/claims/role "

" So au lieu d'utiliser le RoleManager , vous pouvez "ajouter un utilisateur à un rôle" à partir du UserManager , faire 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 que vous avez ajouté une déclaration de rôle avec la valeur "administrateur" pour l'utilisateur avec l'id "1"...

Demandes d'autorisation, comme suggéré par MSFT, permettent de simplifier et d'améliorer les performances de l'authentification et de l'autorisation des processus de l'élimination de certains des requêtes à chaque fois que l'autorisation a lieu.

en utilisant des revendications vous n'avez peut-être plus besoin du RoleStore. (Aspnetruserroles, AspNetUserRoles)

cherchez-vous quelque chose comme ceci:

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

cochez Aussi l'Identité de l'Utilisateur

Check ce lien: l'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-derrière 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);
        }
    }
}

ci-dessous est une implémentation alternative d'une méthode de contrôleur 'create user' utilisant des rôles basés sur des revendications.

les revendications créées fonctionnent alors avec L'attribut Authorize par exemple [Authorize(Roles =" Admin, User.*, Utilisateur.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 });
    }