Attribution de rôles aux utilisateurs (VB)

par Scott Mitchell

Notes

Depuis la rédaction de cet article, les fournisseurs d’appartenance ASP.NET ont été remplacés par ASP.NET Identity. Nous vous recommandons vivement de mettre à jour les applications pour utiliser la plateforme d’identité ASP.NET plutôt que les fournisseurs d’appartenance proposés au moment de la rédaction de cet article. ASP.NET Identity présente un certain nombre d’avantages par rapport au système d’appartenance ASP.NET, notamment :

• Meilleures performances
• Extensibilité et testabilité améliorées
• Prise en charge d’OAuth, OpenID Connect et de l’authentification à deux facteurs
• Prise en charge des identités basées sur les revendications
• Meilleure interopérabilité avec ASP.Net Core

Télécharger le code ou télécharger pdf

Dans ce tutoriel, nous allons créer deux pages ASP.NET pour vous aider à gérer les utilisateurs appartenant à quels rôles. La première page inclut des fonctionnalités permettant de voir les utilisateurs qui appartiennent à un rôle donné, les rôles auxquels appartient un utilisateur particulier et la possibilité d’attribuer ou de supprimer un utilisateur particulier d’un rôle particulier. Dans la deuxième page, nous allons augmenter le contrôle CreateUserWizard afin qu’il inclue une étape pour spécifier les rôles auxquels appartient l’utilisateur nouvellement créé. Cela est utile dans les scénarios où un administrateur est en mesure de créer de nouveaux comptes d’utilisateur.

Introduction

Le tutoriel précédent a examiné l’infrastructure Rôles et le SqlRoleProvider; nous avons vu comment utiliser la Roles classe pour créer, récupérer et supprimer des rôles. En plus de créer et de supprimer des rôles, nous devons être en mesure d’affecter ou de supprimer des utilisateurs d’un rôle. Malheureusement, ASP.NET n’est fourni avec aucun contrôle Web pour la gestion des utilisateurs appartenant à quels rôles. Au lieu de cela, nous devons créer nos propres pages ASP.NET pour gérer ces associations. La bonne nouvelle est que l’ajout et la suppression d’utilisateurs à des rôles sont assez faciles. La Roles classe contient un certain nombre de méthodes permettant d’ajouter un ou plusieurs utilisateurs à un ou plusieurs rôles.

Dans ce tutoriel, nous allons créer deux pages ASP.NET pour vous aider à gérer les utilisateurs appartenant à quels rôles. La première page inclut des fonctionnalités permettant de voir les utilisateurs qui appartiennent à un rôle donné, les rôles auxquels appartient un utilisateur particulier et la possibilité d’attribuer ou de supprimer un utilisateur particulier d’un rôle particulier. Dans la deuxième page, nous allons augmenter le contrôle CreateUserWizard afin qu’il inclue une étape pour spécifier les rôles auxquels appartient l’utilisateur nouvellement créé. Cela est utile dans les scénarios où un administrateur est en mesure de créer de nouveaux comptes d’utilisateur.

C’est parti !

Liste des utilisateurs appartenant à quels rôles

La première étape de ce didacticiel consiste à créer une page web à partir de laquelle les utilisateurs peuvent être affectés à des rôles. Avant de nous préoccuper de la façon d’affecter des utilisateurs à des rôles, nous allons d’abord nous concentrer sur la façon de déterminer quels utilisateurs appartiennent à quels rôles. Il existe deux façons d’afficher ces informations : « par rôle » ou « par utilisateur ». Nous pouvons autoriser le visiteur à sélectionner un rôle et à lui montrer tous les utilisateurs qui appartiennent au rôle (l’affichage « par rôle »), ou nous pouvons inviter le visiteur à sélectionner un utilisateur et à lui montrer les rôles attribués à cet utilisateur (l’affichage « par utilisateur »).

La vue « par rôle » est utile dans les cas où le visiteur souhaite connaître l’ensemble d’utilisateurs appartenant à un rôle particulier ; la vue « par utilisateur » est idéale lorsque le visiteur a besoin de connaître le ou les rôles d’un utilisateur particulier. Nous allons que notre page inclue à la fois les interfaces « par rôle » et « par utilisateur ».

Nous allons commencer par créer l’interface « par utilisateur ». Cette interface se compose d’une liste déroulante et d’une liste de cases à cocher. La liste déroulante est remplie avec l’ensemble d’utilisateurs dans le système ; les cases à cocher énumèrent les rôles. La sélection d’un utilisateur dans la liste déroulante case activée les rôles auxquels l’utilisateur appartient. La personne qui visite la page peut ensuite case activée ou décocher les cases pour ajouter ou supprimer l’utilisateur sélectionné des rôles correspondants.

Notes

L’utilisation d’une liste déroulante pour répertorier les comptes d’utilisateur n’est pas un choix idéal pour les sites web où il peut y avoir des centaines de comptes d’utilisateur. Une liste déroulante est conçue pour permettre à un utilisateur de choisir un élément dans une liste relativement courte d’options. Il devient rapidement difficile à mesure que le nombre d’éléments de liste augmente. Si vous créez un site web qui aura potentiellement un grand nombre de comptes d’utilisateur, vous pouvez envisager d’utiliser une autre interface utilisateur, telle qu’une interface paginable GridView ou une interface filtrable qui invite le visiteur à choisir une lettre, puis affiche uniquement les utilisateurs dont le nom d’utilisateur commence par la lettre sélectionnée.

Étape 1 : Création de l’interface utilisateur « Par utilisateur »

Ouvrez la UsersAndRoles.aspx page. En haut de la page, ajoutez un contrôle Label Web nommé ActionStatus et effacez sa Text propriété. Nous utiliserons cette étiquette pour fournir des commentaires sur les actions effectuées, en affichant des messages tels que « L’utilisateur Tito a été ajouté au rôle Administrateurs » ou « L’utilisateur Jisun a été supprimé du rôle Superviseurs ». Pour que ces messages se distinguent, définissez la propriété label CssClass sur « Important ».

<p align="center"> 
     <asp:Label ID="ActionStatus" runat="server" CssClass="Important"> </asp:Label> 
</p>

Ensuite, ajoutez la définition de classe CSS suivante à la feuille de Styles.css style :

.Important 
{ 
     font-size: large; 
     color: Red; 
}

Cette définition CSS indique au navigateur d’afficher l’étiquette à l’aide d’une grande police rouge. La figure 1 montre cet effet via le Designer Visual Studio.

Figure 1 : La propriété de l’étiquette CssClass génère une grande police rouge (cliquer pour afficher l’image en taille réelle)

Ensuite, ajoutez un DropDownList à la page, définissez sa ID propriété sur UserListet définissez sa AutoPostBack propriété sur True. Nous allons utiliser cette liste déroulante pour répertorier tous les utilisateurs du système. Ce DropDownList sera lié à une collection d’objets MembershipUser. Étant donné que nous voulons que DropDownList affiche la propriété UserName de l’objet MembershipUser (et l’utilise comme valeur des éléments de liste), définissez les propriétés et DataValueField de DataTextField DropDownList sur « UserName ».

Sous dropDownList, ajoutez un répéteur nommé UsersRoleList. Ce répéteur répertorie tous les rôles dans le système sous la forme d’une série de cases à cocher. Définissez le répéteur à l’aide du ItemTemplate balisage déclaratif suivant :

<asp:Repeater ID="UsersRoleList" runat="server"> 
     <ItemTemplate> 
          <asp:CheckBox runat="server" ID="RoleCheckBox" AutoPostBack="true" 
               Text='<%# Container.DataItem %>' /> 
          <br /> 
     </ItemTemplate> 
</asp:Repeater>

Le ItemTemplate balisage inclut un seul contrôle Web CheckBox nommé RoleCheckBox. La propriété checkBox AutoPostBack a la valeur True et la Text propriété est liée à Container.DataItem. La raison pour laquelle la syntaxe de liaison de données est simplement Container.DataItem parce que l’infrastructure Roles retourne la liste des noms de rôles sous la forme d’un tableau de chaînes, et c’est ce tableau de chaînes que nous allons lier au répéteur. Une description détaillée de la raison pour laquelle cette syntaxe est utilisée pour afficher le contenu d’un tableau lié à un contrôle Web de données dépasse la portée de ce didacticiel. Pour plus d’informations sur cette question, consultez Liaison d’un tableau scalaire à un contrôle Web de données.

À ce stade, le balisage déclaratif de votre interface « par utilisateur » doit ressembler à ce qui suit :

<h3>Manage Roles By User</h3> 
<p> 
     <b>Select a User:</b> 
     <asp:DropDownList ID="UserList" runat="server" AutoPostBack="True" 
          DataTextField="UserName" DataValueField="UserName"> 
     </asp:DropDownList> 
</p> 
<p> 
     <asp:Repeater ID="UsersRoleList" runat="server"> 
          <ItemTemplate> 
               <asp:CheckBox runat="server" ID="RoleCheckBox" AutoPostBack="true" 
                    Text='<%# Container.DataItem %>' /> 
               <br /> 
          </ItemTemplate> 
     </asp:Repeater> 
</p>

Nous sommes maintenant prêts à écrire le code pour lier l’ensemble de comptes d’utilisateur au DropDownList et l’ensemble de rôles au répéteur. Dans la classe code-behind de la page, ajoutez une méthode nommée BindUsersToUserList et une autre nommée BindRolesList, à l’aide du code suivant :

Private Sub BindUsersToUserList() 
     ' Get all of the user accounts 
     Dim users As MembershipUserCollection = Membership.GetAllUsers() 
     UserList.DataSource = users 
     UserList.DataBind() 
End Sub 
 
Private Sub BindRolesToList() 
     ' Get all of the roles 
     Dim roleNames() As String = Roles.GetAllRoles() 
     UsersRoleList.DataSource = roleNames 
     UsersRoleList.DataBind() 
End Sub

La BindUsersToUserList méthode récupère tous les comptes d’utilisateur dans le système via la Membership.GetAllUsers méthode . Cette opération retourne un MembershipUserCollection objet, qui est une collection d’instancesMembershipUser. Cette collection est ensuite liée à DropDownList UserList . Les MembershipUser instances qui maquillagent la collection contiennent diverses propriétés, telles UserNameque , Email, CreationDateet IsOnline. Pour indiquer à DropDownList d’afficher la valeur de la UserName propriété, vérifiez que les UserList propriétés et DataValueField de DataTextField DropDownList ont été définies sur « UserName ».

Notes

La Membership.GetAllUsers méthode a deux surcharges : une qui n’accepte aucun paramètre d’entrée et retourne tous les utilisateurs, et une autre qui prend des valeurs entières pour l’index de page et la taille de page, et retourne uniquement le sous-ensemble spécifié des utilisateurs. Lorsque de grandes quantités de comptes d’utilisateur sont affichés dans un élément d’interface utilisateur paginable, la deuxième surcharge peut être utilisée pour parcourir plus efficacement les utilisateurs, car elle retourne uniquement le sous-ensemble précis des comptes d’utilisateur plutôt que tous d’entre eux.

La BindRolesToList méthode commence par appeler la méthode de GetAllRolesla Roles classe, qui retourne un tableau de chaînes contenant les rôles dans le système. Ce tableau de chaînes est ensuite lié au répéteur.

Enfin, nous devons appeler ces deux méthodes lorsque la page est chargée pour la première fois. Ajoutez le code suivant au gestionnaire d'événements Page_Load :

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load 
     If Not Page.IsPostBack Then 
          ' Bind the users and roles 
          BindUsersToUserList() 
          BindRolesToList() 
     End If 
End Sub

Une fois ce code en place, prenez un moment pour visiter la page via un navigateur ; votre écran doit ressembler à la figure 2. Tous les comptes d’utilisateur sont renseignés dans la liste déroulante et, en dessous, chaque rôle apparaît sous la forme d’une case à cocher. Étant donné que nous définissons les AutoPostBack propriétés de DropDownList et CheckBoxes sur True, la modification de l’utilisateur sélectionné ou la vérification ou la désactivation d’un rôle entraîne une publication. Toutefois, aucune action n’est effectuée, car nous n’avons pas encore écrit de code pour gérer ces actions. Nous aborderons ces tâches dans les deux sections suivantes.

Figure 2 : La page affiche les utilisateurs et les rôles (cliquer pour afficher l’image en taille réelle)

Vérification des rôles auxquels appartient l’utilisateur sélectionné

Lorsque la page est chargée pour la première fois, ou chaque fois que le visiteur sélectionne un nouvel utilisateur dans la liste déroulante, nous devons mettre à jour les UsersRoleListcases à cocher de sorte qu’une case à cocher de rôle donné soit cochée uniquement si l’utilisateur sélectionné appartient à ce rôle. Pour ce faire, créez une méthode nommée CheckRolesForSelectedUser avec le code suivant :

Private Sub CheckRolesForSelectedUser() 
     ' Determine what roles the selected user belongs to 
     Dim selectedUserName As String = UserList.SelectedValue 
     Dim selectedUsersRoles() As String = Roles.GetRolesForUser(selectedUserName) 
 
     ' Loop through the Repeater's Items and check or uncheck the checkbox as needed 
     For Each ri As RepeaterItem In UsersRoleList.Items 
          ' Programmatically reference the CheckBox 
          Dim RoleCheckBox As CheckBox = CType(ri.FindControl("RoleCheckBox"), CheckBox) 
          ' See if RoleCheckBox.Text is in selectedUsersRoles 
          If Linq.Enumerable.Contains(Of String)(selectedUsersRoles, RoleCheckBox.Text) Then 
               RoleCheckBox.Checked = True 
          Else 
               RoleCheckBox.Checked = False 
          End If 
     Next 
End Sub

Le code ci-dessus commence par déterminer qui est l’utilisateur sélectionné. Il utilise ensuite la méthode de GetRolesForUser(userName) la classe Roles pour renvoyer l’ensemble de rôles de l’utilisateur spécifié en tant que tableau de chaînes. Ensuite, les éléments du répéteur sont énumérés et la case CheckBox de RoleCheckBox chaque élément est référencée par programmation. Le CheckBox est vérifié uniquement si le rôle auquel il correspond est contenu dans le tableau de selectedUsersRoles chaînes.

Notes

La Linq.Enumerable.Contains(Of String)(...) syntaxe ne sera pas compilée si vous utilisez ASP.NET version 2.0. La Contains(Of String) méthode fait partie de la bibliothèque LINQ, qui est nouvelle pour ASP.NET 3.5. Si vous utilisez toujours ASP.NET version 2.0, utilisez la méthode à la Array.IndexOf(Of String) place.

La CheckRolesForSelectedUser méthode doit être appelée dans deux cas : lorsque la page est chargée pour la première fois et chaque fois que l’index UserList sélectionné de DropDownList est modifié. Par conséquent, appelez cette méthode à partir du Page_Load gestionnaire d’événements (après les appels à BindUsersToUserList et BindRolesToList). Créez également un gestionnaire d’événements pour l’événement SelectedIndexChanged de DropDownList et appelez cette méthode à partir de là.

Protected Sub Page_Load(ByVal sender As Object,ByVal e As System.EventArgs) Handles Me.Load 
     If Not Page.IsPostBack Then 
          ' Bind the users and roles 
          BindUsersToUserList() 
          BindRolesToList() 
          ' Check the selected user's roles 
          CheckRolesForSelectedUser() 
     End If 
End Sub 
 
... 
 
Protected Sub UserList_SelectedIndexChanged(ByVal sender As Object,ByVal e As System.EventArgs) Handles UserList.SelectedIndexChanged 
     CheckRolesForSelectedUser() 
End Sub

Une fois ce code en place, vous pouvez tester la page via le navigateur. Toutefois, étant donné que la UsersAndRoles.aspx page n’a actuellement pas la possibilité d’affecter des utilisateurs à des rôles, aucun utilisateur n’a de rôle. Nous allons créer l’interface permettant d’affecter des utilisateurs à des rôles dans un instant, afin que vous puissiez soit me dire que ce code fonctionne et vérifier qu’il le fait ultérieurement, ou vous pouvez ajouter manuellement des utilisateurs à des rôles en insérant des enregistrements dans la aspnet_UsersInRoles table afin de tester cette fonctionnalité maintenant.

Affectation et suppression d’utilisateurs de rôles

Lorsque le visiteur vérifie ou désactive une case à cocher dans le UsersRoleList répéteur, nous devons ajouter ou supprimer l’utilisateur sélectionné du rôle correspondant. La propriété de AutoPostBack CheckBox est actuellement définie sur True, ce qui entraîne une publication de publication chaque fois qu’une case CheckBox dans le répétiteur est cochée ou décochée. En bref, nous devons créer un gestionnaire d’événements pour l’événement CheckChanged CheckBox. Étant donné que checkBox se trouve dans un contrôle Repeater, nous devons ajouter manuellement la plomberie du gestionnaire d’événements. Commencez par ajouter le gestionnaire d’événements à la classe code-behind en tant que Protected méthode, comme suit :

Protected Sub RoleCheckBox_CheckChanged(ByVal sender As Object, ByVal e As EventArgs) 
 
End Sub

Nous allons revenir pour écrire le code de ce gestionnaire d’événements dans un instant. Mais nous allons d’abord terminer la gestion des événements de plomberie. À partir de la Case à cocher dans le répéteur ItemTemplate, ajoutez OnCheckedChanged="RoleCheckBox_CheckChanged". Cette syntaxe relie le RoleCheckBox_CheckChanged gestionnaire d’événements à l’événement RoleCheckBoxde CheckedChanged .

<asp:CheckBox runat="server" ID="RoleCheckBox" 
     AutoPostBack="true" 
     Text='<%# Container.DataItem %>' 
     OnCheckedChanged="RoleCheckBox_CheckChanged" />

Notre dernière tâche consiste à terminer le gestionnaire d’événements RoleCheckBox_CheckChanged . Nous devons commencer par référencer le contrôle CheckBox qui a déclenché l’événement, car cette instance CheckBox nous indique quel rôle a été vérifié ou décoché via ses Text propriétés etChecked. À l’aide de ces informations avec le UserName de l’utilisateur sélectionné, nous ajoutons ou supprimons l’utilisateur du rôle par le biais de la classe ou RemoveUserFromRolede AddUserToRole la Roles méthode.

Protected Sub RoleCheckBox_CheckChanged(ByVal sender As Object, ByVal e As EventArgs) 
     'Reference the CheckBox that raised this event 
     Dim RoleCheckBox As CheckBox = CType(sender, CheckBox) 
 
     ' Get the currently selected user and role 
     Dim selectedUserName As String = UserList.SelectedValue 
     Dim roleName As String = RoleCheckBox.Text 
 
     ' Determine if we need to add or remove the user from this role 
     If RoleCheckBox.Checked Then 
          ' Add the user to the role 
          Roles.AddUserToRole(selectedUserName, roleName) 
          ' Display a status message 
          ActionStatus.Text = String.Format("User {0} was added to role {1}.", selectedUserName,roleName) 
     Else 
          ' Remove the user from the role 
          Roles.RemoveUserFromRole(selectedUserName, roleName) 
          ' Display a status message 
          ActionStatus.Text = String.Format("User {0} was removed from role {1}.", selectedUserName,roleName) 
     End If 
End Sub

Le code ci-dessus commence par référencer par programmation la CheckBox qui a déclenché l’événement, qui est disponible via le paramètre d’entrée sender . Si la case CheckBox est cochée, l’utilisateur sélectionné est ajouté au rôle spécifié. Sinon, il est supprimé du rôle. Dans les deux cas, l’étiquette ActionStatus affiche un message résumant l’action qui vient d’être effectuée.

Prenez un moment pour tester cette page via un navigateur. Sélectionnez L’utilisateur Tito, puis ajoutez Tito aux rôles Administrateurs et Superviseurs.

Figure 3 : Tito a été ajouté aux rôles Administrateurs et superviseurs (cliquez pour afficher l’image en taille réelle)

Ensuite, sélectionnez user Bruce dans la liste déroulante. Il existe une publication et les CheckBox du répéteur sont mis à jour via le CheckRolesForSelectedUser. Étant donné que Bruce n’appartient à aucun rôle, les deux cases à cocher sont décochées. Ensuite, ajoutez Bruce au rôle Superviseurs.

Figure 4 : Bruce a été ajouté au rôle Superviseurs (cliquez pour afficher l’image en taille réelle)

Pour vérifier davantage les fonctionnalités de la CheckRolesForSelectedUser méthode, sélectionnez un utilisateur autre que Tito ou Bruce. Notez que les cases à cocher sont automatiquement décochées, indiquant qu’elles n’appartiennent à aucun rôle. Revenez à Tito. Les cases Administrateurs et Superviseurs doivent être cochées.

Étape 2 : Génération de l’interface utilisateur « Par rôles »

À ce stade, nous avons terminé l’interface « par les utilisateurs » et nous sommes prêts à commencer à aborder l’interface « par rôles ». L’interface « par rôles » invite l’utilisateur à sélectionner un rôle dans une liste déroulante, puis affiche l’ensemble d’utilisateurs qui appartiennent à ce rôle dans un GridView.

Ajoutez un autre contrôle DropDownList à .UsersAndRoles.aspx page Placez celui-ci sous le contrôle Repeater, nommez-le RoleListet définissez sa AutoPostBack propriété sur True. En dessous, ajoutez un GridView et nommez-le RolesUserList. Ce GridView répertorie les utilisateurs qui appartiennent au rôle sélectionné. Définissez la propriété de AutoGenerateColumns GridView sur False, ajoutez un TemplateField à la collection de Columns la grille et définissez sa HeaderText propriété sur « Users ». Définissez le templateField de sorte qu’il ItemTemplate affiche la valeur de l’expression Container.DataItem de liaison de données dans la Text propriété d’une étiquette nommée UserNameLabel.

Après avoir ajouté et configuré GridView, le balisage déclaratif de votre interface « par rôle » doit ressembler à ce qui suit :

<h3>Manage Users By Role</h3> 
<p> 
     <b>Select a Role:</b> 
     <asp:DropDownList ID="RoleList" runat="server" AutoPostBack="true"></asp:DropDownList> 
</p> 
<p> 
     <asp:GridView ID="RolesUserList" runat="server" AutoGenerateColumns="false" 
          EmptyDataText="No users belong to this role."> 
          <Columns> 
               <asp:TemplateField HeaderText="Users"> 
                    <ItemTemplate> 
                         <asp:Label runat="server" id="UserNameLabel" 
                              Text='<%# Container.DataItem %>'></asp:Label> 
                    </ItemTemplate> 
               </asp:TemplateField> 
          </Columns> 
     </asp:GridView> 
</p>

Nous devons remplir le RoleList DropDownList avec l’ensemble des rôles dans le système. Pour ce faire, mettez à jour la BindRolesToList méthode afin de lier le tableau de chaînes retourné par la Roles.GetAllRoles méthode au DropDownList (ainsi qu’au RolesListUsersRoleList répéteur).

Private Sub BindRolesToList() 
     ' Get all of the roles 
     Dim roleNames() As String = Roles.GetAllRoles() 
     UsersRoleList.DataSource = roleNames 
     UsersRoleList.DataBind() 
 
     RoleList.DataSource = roleNames 
     RoleList.DataBind() 
End Sub

Les deux dernières lignes de la BindRolesToList méthode ont été ajoutées pour lier l’ensemble de rôles au RoleList contrôle DropDownList. La figure 5 montre le résultat final en cas d’affichage via un navigateur : une liste déroulante remplie avec les rôles du système.

Figure 5 : Les rôles sont affichés dans la RoleList liste déroulante (cliquez pour afficher l’image en taille réelle)

Affichage des utilisateurs qui appartiennent au rôle sélectionné

Lorsque la page est chargée pour la première fois ou lorsqu’un nouveau rôle est sélectionné dans la RoleList Liste déroulante, nous devons afficher la liste des utilisateurs qui appartiennent à ce rôle dans GridView. Créez une méthode nommée DisplayUsersBelongingToRole à l’aide du code suivant :

Private Sub DisplayUsersBelongingToRole() 
     ' Get the selected role 
     Dim selectedRoleName As String = RoleList.SelectedValue 
 
     ' Get the list of usernames that belong to the role 
     Dim usersBelongingToRole() As String = Roles.GetUsersInRole(selectedRoleName) 
 
     ' Bind the list of users to the GridView 
     RolesUserList.DataSource = usersBelongingToRole 
     RolesUserList.DataBind() 
End Sub

Cette méthode commence par obtenir le rôle sélectionné à partir de DropDownList RoleList . Il utilise ensuite la Roles.GetUsersInRole(roleName) méthode pour récupérer un tableau de chaînes des UserNames des utilisateurs qui appartiennent à ce rôle. Ce tableau est ensuite lié à GridView RolesUserList .

Cette méthode doit être appelée dans deux cas : lorsque la page est initialement chargée et lorsque le rôle sélectionné dans dropDownList RoleList change. Par conséquent, mettez à jour le Page_Load gestionnaire d’événements afin que cette méthode soit appelée après l’appel à CheckRolesForSelectedUser. Ensuite, créez un gestionnaire d’événements pour l’événement RoleListde SelectedIndexChanged , puis appelez cette méthode à partir de là également.

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load 
     If Not Page.IsPostBack Then 
          ' Bind the users and roles 
          BindUsersToUserList() 
          BindRolesToList() 
 
          ' Check the selected user's roles 
          CheckRolesForSelectedUser() 
 
          'Display those users belonging to the currently selected role 
          DisplayUsersBelongingToRole() 
     End If 
End Sub 
 
... 
 
Protected Sub RoleList_SelectedIndexChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles RoleList.SelectedIndexChanged 
     DisplayUsersBelongingToRole() 
End Sub

Une fois ce code en place, GridView RolesUserList doit afficher les utilisateurs qui appartiennent au rôle sélectionné. Comme le montre la figure 6, le rôle Superviseurs se compose de deux membres : Bruce et Tito.

Figure 6 : GridView répertorie les utilisateurs qui appartiennent au rôle sélectionné (cliquer pour afficher l’image en taille réelle)

Suppression d’utilisateurs du rôle sélectionné

Augmentons le RolesUserList GridView afin qu’il inclue une colonne de boutons « Supprimer ». Cliquez sur le bouton « Supprimer » pour un utilisateur particulier pour le supprimer de ce rôle.

Commencez par ajouter un champ de bouton Supprimer à GridView. Faites apparaître ce champ comme le plus classé à gauche et remplacez sa DeleteText propriété de « Delete » (par défaut) par « Remove ».

Figure 7 : Ajouter le bouton « Supprimer » à GridView (cliquer pour afficher l’image en taille réelle)

Lorsque vous cliquez sur le bouton « Supprimer », une publication s’ensuit et l’événement gridView RowDeleting est déclenché. Nous devons créer un gestionnaire d’événements pour cet événement et écrire du code qui supprime l’utilisateur du rôle sélectionné. Créez le gestionnaire d’événements, puis ajoutez le code suivant :

Protected Sub RolesUserList_RowDeleting(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewDeleteEventArgs) Handles RolesUserList.RowDeleting 
     ' Get the selected role 
     Dim selectedRoleName As String = RoleList.SelectedValue 
 
     ' Reference the UserNameLabel 
     Dim UserNameLabel As Label = CType(RolesUserList.Rows(e.RowIndex).FindControl("UserNameLabel"),Label) 
 
     ' Remove the user from the role 
     Roles.RemoveUserFromRole(UserNameLabel.Text, selectedRoleName) 
 
     ' Refresh the GridView 
     DisplayUsersBelongingToRole() 
 
     ' Display a status message 
     ActionStatus.Text = String.Format("User {0} was removed from role {1}.", UserNameLabel.Text,selectedRoleName) 
End Sub

Le code commence par déterminer le nom du rôle sélectionné. Il fait ensuite référence par programmation au UserNameLabel contrôle à partir de la ligne dont le bouton « Supprimer » a été cliqué afin de déterminer le Nom d’utilisateur de l’utilisateur à supprimer. L’utilisateur est ensuite supprimé du rôle via un appel à la Roles.RemoveUserFromRole méthode . GridView RolesUserList est ensuite actualisé et un message s’affiche via le ActionStatus contrôle Label.

Notes

Le bouton « Supprimer » ne nécessite aucune confirmation de la part de l’utilisateur avant de le supprimer du rôle. Je vous invite à ajouter un niveau de confirmation utilisateur. L’un des moyens les plus simples de confirmer une action consiste à utiliser une boîte de dialogue de confirmation côté client. Pour plus d’informations sur cette technique, consultez Ajout de Client-Side confirmation lors de la suppression.

La figure 8 montre la page après la suppression de l’utilisateur Tito du groupe Superviseurs.

Figure 8 : Hélas, Tito n’est plus un superviseur (cliquer pour afficher l’image en taille réelle)

Ajout de nouveaux utilisateurs au rôle sélectionné

En plus de supprimer des utilisateurs du rôle sélectionné, le visiteur de cette page doit également être en mesure d’ajouter un utilisateur au rôle sélectionné. La meilleure interface pour ajouter un utilisateur au rôle sélectionné dépend du nombre de comptes d’utilisateur que vous prévoyez d’avoir. Si votre site web ne contiendra que quelques dizaines de comptes d’utilisateur ou moins, vous pouvez utiliser une liste déroulante ici. S’il peut y avoir des milliers de comptes d’utilisateur, vous souhaitez inclure une interface utilisateur qui permet au visiteur de parcourir les comptes, de rechercher un compte particulier ou de filtrer les comptes d’utilisateur d’une autre manière.

Pour cette page, nous allons utiliser une interface très simple qui fonctionne quel que soit le nombre de comptes d’utilisateur dans le système. À savoir, nous allons utiliser une zone de texte, invitant le visiteur à taper le nom d’utilisateur de l’utilisateur qu’elle souhaite ajouter au rôle sélectionné. S’il n’existe aucun utilisateur portant ce nom ou si l’utilisateur est déjà membre du rôle, nous afficherons un message dans ActionStatus Étiquette. Mais si l’utilisateur existe et n’est pas membre du rôle, nous allons l’ajouter au rôle et actualiser la grille.

Ajoutez une zone de texte et un bouton sous GridView. Définissez le textBox IDUserNameToAddToRole sur et définissez les propriétés et Text les propriétés du ID bouton sur AddUserToRoleButton et sur « Ajouter un utilisateur au rôle », respectivement.

<p> 
     <b>UserName:</b> 
     <asp:TextBox ID="UserNameToAddToRole" runat="server"></asp:TextBox> 
     <br /> 
     <asp:Button ID="AddUserToRoleButton" runat="server" Text="Add User to Role" /> 
</p>

Ensuite, créez un gestionnaire d’événements Click pour le AddUserToRoleButton et ajoutez le code suivant :

Protected Sub AddUserToRoleButton_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles AddUserToRoleButton.Click 
     ' Get the selected role and username 
     Dim selectedRoleName As String = RoleList.SelectedValue 
     Dim userToAddToRole As String = UserNameToAddToRole.Text 
 
     ' Make sure that a value was entered 
     If userToAddToRole.Trim().Length = 0 Then 
          ActionStatus.Text = "You must enter a username in the textbox." 
          Exit Sub 
     End If 
 
     ' Make sure that the user exists in the system 
     Dim userInfo As MembershipUser = Membership.GetUser(userToAddToRole) 
     If userInfo Is Nothing Then 
          ActionStatus.Text = String.Format("The user {0} does not exist in the system.",userNameToAddToRole) 
          Exit Sub 
     End If 
 
     ' Make sure that the user doesn't already belong to this role 
     If Roles.IsUserInRole(userToAddToRole, selectedRoleName) Then 
          ActionStatus.Text = String.Format("User {0} already is a member of role {1}.", UserNameToAddToRole,selectedRoleName) 
          Exit Sub 
     End If 
 
     ' If we reach here, we need to add the user to the role 
     Roles.AddUserToRole(userToAddToRole, selectedRoleName) 
 
     ' Clear out the TextBox 
     userNameToAddToRole.Text = String.Empty 
 
     ' Refresh the GridView 
     DisplayUsersBelongingToRole() 
 
     ' Display a status message 
     ActionStatus.Text = String.Format("User {0} was added to role {1}.", UserNameToAddToRole,selectedRoleName) 
End Sub

La majorité du code dans le gestionnaire d’événements Click effectue diverses vérifications de validation. Cela garantit que le visiteur a fourni un nom d’utilisateur dans textBox UserNameToAddToRole , que l’utilisateur existe dans le système et qu’il n’appartient pas déjà au rôle sélectionné. Si l’une de ces vérifications échoue, un message approprié s’affiche dans ActionStatus et le gestionnaire d’événements est arrêté. Si toutes les vérifications réussissent, l’utilisateur est ajouté au rôle via la Roles.AddUserToRole méthode . Par la suite, la propriété de Text TextBox est effacée, le GridView est actualisé et l’étiquette ActionStatus affiche un message indiquant que l’utilisateur spécifié a été correctement ajouté au rôle sélectionné.

Notes

Pour nous assurer que l’utilisateur spécifié n’appartient pas déjà au rôle sélectionné, nous utilisons la Roles.IsUserInRole(userName, roleName) méthode , qui retourne une valeur booléenne indiquant si userName est membre de roleName. Nous utiliserons à nouveau cette méthode dans le tutoriel suivant lorsque nous examinerons l’autorisation basée sur les rôles.

Accédez à la page à l’aide d’un navigateur et sélectionnez le rôle Superviseurs dans dropDownList RoleList . Essayez d’entrer un nom d’utilisateur non valide : vous devriez voir un message expliquant que l’utilisateur n’existe pas dans le système.

Figure 9 : Vous ne pouvez pas ajouter un utilisateur inexistant à un rôle (cliquez pour afficher l’image en taille réelle)

Essayez maintenant d’ajouter un utilisateur valide. Continuez et rajoutez Tito au rôle Superviseurs.

Figure 10 : Tito est de nouveau superviseur! (Cliquez pour afficher l’image en taille réelle)

Étape 3 : Mise à jour croisée des interfaces « Par utilisateur » et « Par rôle »

La UsersAndRoles.aspx page offre deux interfaces distinctes pour la gestion des utilisateurs et des rôles. Actuellement, ces deux interfaces agissent indépendamment l’une de l’autre. Il est donc possible qu’une modification apportée dans une interface ne soit pas reflétée immédiatement dans l’autre. Par exemple, imaginez que le visiteur de la page sélectionne le rôle Superviseurs dans le RoleList DropDownList, qui répertorie Bruce et Tito comme membres. Ensuite, le visiteur sélectionne Tito dans dropDownList UserList , qui coche les cases Administrateurs et Superviseurs dans le UsersRoleList répéteur. Si le visiteur désactive ensuite le rôle Superviseur du répéteur, Tito est supprimé du rôle Superviseurs, mais cette modification n’est pas répercutée dans l’interface « par rôle ». GridView affiche toujours Tito comme membre du rôle Superviseurs.

Pour résoudre ce problème, nous devons actualiser l’objet GridView chaque fois qu’un rôle est activé ou décoché à partir du UsersRoleList répéteur. De même, nous devons actualiser le répéteur chaque fois qu’un utilisateur est supprimé ou ajouté à un rôle à partir de l’interface « par rôle ».

Le répéteur dans l’interface « by user » est actualisé en appelant la CheckRolesForSelectedUser méthode . L’interface « par rôle » peut être modifiée dans le RolesUserList gestionnaire d’événements gridView RowDeleting et le AddUserToRoleButton gestionnaire d’événements de Click Button. Par conséquent, nous devons appeler la CheckRolesForSelectedUser méthode à partir de chacune de ces méthodes.

Protected Sub RolesUserList_RowDeleting(ByVal sender As Object, ByVal e As System.Web.UI.WebControls.GridViewDeleteEventArgs) Handles RolesUserList.RowDeleting 
     ... Code removed for brevity ... 
 
     ' Refresh the "by user" interface 
     CheckRolesForSelectedUser() 
End Sub 
 
Protected Sub AddUserToRoleButton_Click(ByVal sender As Object, ByVal e As System.EventArgs) Handles AddUserToRoleButton.Click 
     ... Code removed for brevity ... 
 
     ' Refresh the "by user" interface 
     CheckRolesForSelectedUser() 
End Sub

De même, gridView dans l’interface « by role » est actualisé en appelant la DisplayUsersBelongingToRole méthode et l’interface « by user » est modifiée via le RoleCheckBox_CheckChanged gestionnaire d’événements. Par conséquent, nous devons appeler la DisplayUsersBelongingToRole méthode à partir de ce gestionnaire d’événements.

Protected Sub RoleCheckBox_CheckChanged(ByVal sender As Object, ByVal e As EventArgs) 
     ... Code removed for brevity ... 
 
     ' Refresh the "by role" interface 
     DisplayUsersBelongingToRole() 
End Sub

Avec ces modifications mineures du code, les interfaces « par utilisateur » et « par rôle » sont désormais correctement mises à jour croisées. Pour vérifier cela, visitez la page via un navigateur et sélectionnez Tito et superviseurs dans les UserList listes déroulantes et RoleList , respectivement. Notez que lorsque vous décochez le rôle Superviseurs pour Tito du répéteur dans l’interface « by user », Tito est automatiquement supprimé de GridView dans l’interface « by role ». L’ajout de Tito au rôle Superviseurs à partir de l’interface « par rôle » réactive automatiquement la case Superviseurs dans l’interface « par utilisateur ».

Étape 4 : Personnalisation de CreateUserWizard pour inclure une étape « Spécifier des rôles »

Dans le didacticiel Création de comptes d’utilisateur, nous avons vu comment utiliser le contrôle Web CreateUserWizard pour fournir une interface permettant de créer un compte d’utilisateur. Le contrôle CreateUserWizard peut être utilisé de l’une des deux manières suivantes :

• Comme moyen pour les visiteurs de créer leur propre compte d’utilisateur sur le site, et
• Comme moyen pour les administrateurs de créer de nouveaux comptes

Dans le premier cas d’usage, un visiteur vient sur le site et remplit le CreateUserWizard, en entrant ses informations pour s’inscrire sur le site. Dans le deuxième cas, un administrateur crée un compte pour une autre personne.

Lorsqu’un compte est créé par un administrateur pour une autre personne, il peut être utile de permettre à l’administrateur de spécifier les rôles auxquels appartient le nouveau compte d’utilisateur. Dans le didacticiel Stockaged’informations supplémentaires sur les utilisateurs, nous avons vu comment personnaliser createUserWizard en ajoutant des informations supplémentairesWizardSteps. Voyons comment ajouter une étape supplémentaire à CreateUserWizard afin de spécifier les rôles du nouvel utilisateur.

Ouvrez la CreateUserWizardWithRoles.aspx page et ajoutez un contrôle CreateUserWizard nommé RegisterUserWithRoles. Définissez la propriété du ContinueDestinationPageUrl contrôle sur « ~/Default.aspx ». Étant donné qu’un administrateur utilise ce contrôle CreateUserWizard pour créer des comptes d’utilisateur, définissez la propriété du LoginCreatedUser contrôle sur False. Cette LoginCreatedUser propriété spécifie si le visiteur est automatiquement connecté en tant qu’utilisateur qui vient de créer, et si la valeur par défaut est True. Nous lui définissons la valeur False, car quand un administrateur crée un compte, nous voulons le maintenir connecté en tant que lui-même.

Ensuite, sélectionnez « Ajouter/Supprimer WizardSteps... » à partir de la balise active CreateUserWizard et ajoutez une nouvelle WizardStep, en affectant ID la valeur à SpecifyRolesStep. Déplacez le SpecifyRolesStep WizardStep pour qu’il arrive après l’étape « S’inscrire à votre nouveau compte », mais avant l’étape « Terminer ». Définissez la propriété de Title sur WizardStep« Specify Roles », sa StepType propriété sur Stepet sa AllowReturn propriété sur False.

Figure 11 : Ajouter « Spécifier des rôles » WizardStep à l’objet CreateUserWizard (Cliquez pour afficher l’image en taille réelle)

Après cette modification, le balisage déclaratif de votre CreateUserWizard doit ressembler à ce qui suit :

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

Dans « Spécifier les rôles », WizardStepajoutez une CheckBoxList nommée RoleList. This CheckBoxList listera les rôles disponibles, ce qui permettra à la personne qui visite la page de case activée les rôles auxquels appartient l’utilisateur nouvellement créé.

Il nous reste deux tâches de codage : d’abord, nous devons remplir la RoleList CheckBoxList avec les rôles dans le système; ensuite, nous devons ajouter l’utilisateur créé aux rôles sélectionnés lorsque l’utilisateur passe de l’étape « Spécifier des rôles » à l’étape « Terminer ». Nous pouvons accomplir la première tâche dans le gestionnaire d’événements Page_Load . Le code suivant fait référence par programmation à CheckBox RoleList lors de la première visite à la page et y lie les rôles dans le système.

Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load 
     If Not Page.IsPostBack Then 
          ' Reference the SpecifyRolesStep WizardStep 
          Dim SpecifyRolesStep As WizardStep = CType(RegisterUserWithRoles.FindControl("SpecifyRolesStep"),WizardStep) 
 
          ' Reference the RoleList CheckBoxList 
          Dim RoleList As CheckBoxList = CType(SpecifyRolesStep.FindControl("RoleList"), CheckBoxList) 
 
          ' Bind the set of roles to RoleList 
          RoleList.DataSource = Roles.GetAllRoles() 
          RoleList.DataBind() 
     End If 
End Sub

Le code ci-dessus doit être familier. Dans le didacticiel Stockage d’informationsutilisateur supplémentaires, nous avons utilisé deux FindControl instructions pour référencer un contrôle Web à partir d’un contrôle personnaliséWizardStep. Et le code qui lie les rôles à CheckBoxList a été extrait plus haut dans ce tutoriel.

Pour effectuer la deuxième tâche de programmation, nous devons savoir quand l’étape « Spécifier des rôles » est terminée. Rappelez-vous que CreateUserWizard a un ActiveStepChanged événement, qui se déclenche chaque fois que le visiteur navigue d’une étape à l’autre. Ici, nous pouvons déterminer si l’utilisateur a atteint l’étape « Terminer » ; Si c’est le cas, nous devons ajouter l’utilisateur aux rôles sélectionnés.

Créez un gestionnaire d’événements pour l’événement ActiveStepChanged et ajoutez le code suivant :

Protected Sub RegisterUserWithRoles_ActiveStepChanged(ByVal sender As Object, ByVal e As System.EventArgs) Handles RegisterUserWithRoles.ActiveStepChanged 
     'Have we JUST reached the Complete step? 
     If RegisterUserWithRoles.ActiveStep.Title = "Complete" Then 
          ' Reference the SpecifyRolesStep WizardStep 
          Dim SpecifyRolesStep As WizardStep = CType(RegisterUserWithRoles.FindControl("SpecifyRolesStep"),WizardStep) 
 
          ' Reference the RoleList CheckBoxList 
          Dim RoleList As CheckBoxList = CType(SpecifyRolesStep.FindControl("RoleList"), CheckBoxList) 
 
          ' Add the checked roles to the just-added user 
          For Each li As ListItem In RoleList.Items 
               If li.Selected Then 
                    Roles.AddUserToRole(RegisterUserWithRoles.UserName, li.Text) 
               End If 
          Next 
     End If 
End Sub

Si l’utilisateur vient d’atteindre l’étape « Terminé », le gestionnaire d’événements énumère les éléments du RoleList CheckBoxList et l’utilisateur créé est affecté aux rôles sélectionnés.

Visitez cette page via un navigateur. La première étape de CreateUserWizard est l’étape standard « S’inscrire à votre nouveau compte », qui invite à entrer le nom d’utilisateur, le mot de passe, l’e-mail et d’autres informations clés du nouvel utilisateur. Entrez les informations pour créer un utilisateur nommé Wanda.

Figure 12 : Créer un utilisateur nommé Wanda (Cliquer pour afficher l’image en taille réelle)

Cliquez sur le bouton « Créer un utilisateur ». Le CreateUserWizard appelle en interne la Membership.CreateUser méthode, en créant le compte d’utilisateur, puis passe à l’étape suivante, « Spécifier des rôles ». Ici, les rôles système sont répertoriés. Cochez la case Superviseurs, puis cliquez sur Suivant.

Figure 13 : Faire de Wanda un membre du rôle superviseur (cliquer pour afficher l’image en taille réelle)

Cliquer sur Suivant entraîne une publication et met à jour vers ActiveStep l’étape « Terminer ». Dans le ActiveStepChanged gestionnaire d’événements, le compte d’utilisateur créé récemment est affecté au rôle Superviseurs. Pour vérifier cela, revenez à la UsersAndRoles.aspx page et sélectionnez Superviseurs dans la RoleList liste déroulante. Comme le montre la figure 14, les superviseurs sont maintenant composés de trois utilisateurs : Bruce, Tito et Wanda.

Figure 14 : Bruce, Tito et Wanda sont tous des superviseurs (Cliquez pour afficher l’image en taille réelle)

Résumé

L’infrastructure Rôles propose des méthodes pour récupérer des informations sur les rôles d’un utilisateur particulier et des méthodes pour déterminer quels utilisateurs appartiennent à un rôle spécifié. En outre, il existe plusieurs méthodes permettant d’ajouter et de supprimer un ou plusieurs utilisateurs à un ou plusieurs rôles. Dans ce tutoriel, nous nous sommes concentrés sur deux de ces méthodes : AddUserToRole et RemoveUserFromRole. Il existe d’autres variantes conçues pour ajouter plusieurs utilisateurs à un seul rôle et pour attribuer plusieurs rôles à un seul utilisateur.

Ce tutoriel a également inclus un aperçu de l’extension du contrôle CreateUserWizard pour inclure un WizardStep pour spécifier les rôles de l’utilisateur nouvellement créé. Une telle étape peut aider un administrateur à simplifier le processus de création de comptes d’utilisateur pour de nouveaux utilisateurs.

À ce stade, nous avons vu comment créer et supprimer des rôles et comment ajouter et supprimer des utilisateurs des rôles. Mais nous n’avons pas encore examiné l’application de l’autorisation basée sur les rôles. Dans le tutoriel suivant , nous allons examiner comment définir des règles d’autorisation d’URL rôle par rôle, ainsi que comment limiter les fonctionnalités au niveau de la page en fonction des rôles d’utilisateur actuellement connectés.

Bonne programmation!

En savoir plus

Pour plus d’informations sur les sujets abordés dans ce didacticiel, consultez les ressources suivantes :

• Vue d’ensemble de l’outil d’administration de site web ASP.NET
• Examen d’ASP. Appartenance, rôles et profil de NET

À propos de l’auteur

Scott Mitchell, auteur de plusieurs livres ASP/ASP.NET et fondateur de 4GuysFromRolla.com, travaille avec les technologies Web Microsoft depuis 1998. Scott travaille comme consultant indépendant, formateur et écrivain. Son dernier livre est Sams Teach Yourself ASP.NET 2.0 in 24 Hours. Scott peut être joint à l’adresse mitchell@4guysfromrolla.com ou via son blog à l’adresse http://ScottOnWriting.NET.

Un merci spécial à...

Cette série de tutoriels a été examinée par de nombreux réviseurs utiles. La réviseure principale de ce tutoriel était Teresa Murphy. Vous souhaitez consulter mes prochains articles MSDN ? Si c’est le cas, déposez-moi une ligne à mitchell@4GuysFromRolla.com

PrécédentSuivant