Comment concevoir la base de données d'autorisation et d'authentification

Question

Je normalement dans mes projets utilisent comme ce code:

If user.IsInRole("Admin") Then 
    deleteButton.Visible = True 
else 
    deleteButton.Visible = False 

Mais je veux contrôler les rôles, ce qui peut voir ce bouton dans la base de données.

À cette fin, comment devrait être la conception de base de données?

Merci.

Answer 1

En supposant que vous utilisiez .NET, vous pouvez implémenter vos propres fournisseurs de rôles et d'appartenance. Ensuite, vous pouvez ajouter des fonctionnalités en mettant en œuvre une interface contenant les éléments que vous vouliez (je viens de frappais cet échantillon au large du haut de ma tête, donc je me excuse si elle semble un peu rude):

public interface ICustomRole 
{ 
    bool IsInRole(string userName, object[] params roles); 
} 

public class MyCustomRole : RoleProvider, ICustomRole 
{ 
    public IsInRole(MembershipUser user, object[] params roles) 
    { 
    if (roles == null || roles.Length == 0) 
     throw new ArgumentException("roles"); 
    // Put your logic here for accessing the roles 
    } 
} 

Ensuite, dans votre code, vous le ferez:

bool isValid = ((ICustomRole)Roles.Provider).IsInRole(
    User, new[] { "Admin", "Moderator", "Validator" }); 

Answer 2

Faites le design que vous voulez, mais dans ASP.NET côté, implémentez votre propre MembershipProvider. Cela va traduire votre conception de base de données en utilisateurs/rôles que .NET peut utiliser. Après cela, vous pouvez l'utiliser comme d'habitude - avec user.isInRole("Admin") :)

Answer 3

Eh bien, une conception est d'avoir des tables telles que:

User(UserID, ...) PK = UserID 

Role(RoleID, RoleName, ...) PK = RoleID 

UserHasRole(UserHasRoleID, UserID, RoleID) PK=UserHasRoleID ; Unique= (UserID, RoleID) 

C'est une méthode. C'est un système basé sur les rôles plutôt que sur un système d'autorisation basé sur un objet discrétionnaire (Dans un système discrétionnaire, vous devez définir des permissions sur chaque objet, disons que l'utilisateur x a l'autorisation DELETE pour les clients ou quelque chose comme ça).

Answer 4

Peut-être que je devrais être plus clair, mais je ne sais pas comment :). Je vais réessayer.

Par exemple, je l'utilise pour mon DeleteButton ce code:

if user.isInRole("Admin") then 
    deleteButton.visible = true 
else 
    deleteButton.visible = false 

Afte son ensemble, prendre une décision, l'utilisateur a le rôle devrait également voir le bouton supprimer « modérateur ». Donc, je devrais changer mon code comme ceci:

if user.isInRole("Admin","Moderator") then 
    deleteButton.visible = true 
else 
    deleteButton.visible = false 

Si j'ai une conception de base de données pour prendre le contrôle, je ne l'ai pas besoin de changer mon code pour cela.

Eh bien, Comment devrait-il être?

Answer 5

LDAP est la meilleure option pour l'autorisation et l'authentification. vous pouvez utiliser l'API openLDAP dans le même but.

Answer 6

code:

public class YourSqlRoleProvider : System.Web.Security.RoleProvider 
{ 
    private string ConnectionString { get; set; } 

    public override void AddUsersToRoles(string[] userNames, string[] roleNames) 
    { 
     // logic here 
    } 

    public override string ApplicationName 
    { 
     get 
     { 
      throw new NotSupportedException(); 
     } 
     set 
     { 
      throw new NotSupportedException(); 
     } 
    } 

    public override void CreateRole(string roleName) 
    { 
     throw new NotSupportedException(); 
    } 

    public override bool DeleteRole(string roleName, bool throwOnPopulatedRole) 
    { 
     throw new NotSupportedException(); 
    } 

    public override string[] FindUsersInRole(string roleName, string userNameToMatch) 
    { 
     throw new NotSupportedException(); 
    } 

    public override string[] GetAllRoles() 
    { 
     // logic here 
    } 

    public override string[] GetRolesForUser(string userName) 
    { 
     // logic here 
    } 

    public override string[] GetUsersInRole(string roleName) 
    { 
     throw new NotSupportedException(); 
    } 

    public override bool IsUserInRole(string userName, string roleName) 
    { 
     return GetRolesForUser(userName).Contains(roleName); 
    } 

    public override void Initialize(string name, System.Collections.Specialized.NameValueCollection config) 
    { 
     this.ConnectionString = ConfigurationManager.ConnectionStrings[config["connectionStringName"]].ConnectionString; 

     base.Initialize(name, config); 
    } 

    public override void RemoveUsersFromRoles(string[] userNames, string[] roleNames) 
    { 
     throw new NotSupportedException(); 
    } 

    public override bool RoleExists(string roleName) 
    { 
     throw new NotSupportedException(); 
    } 
} 

Web.config:

<?xml version="1.0" encoding="utf-8"?> 
<configuration> 
    <connectionStrings> 
     <clear /> 
     <add name="YourConnectionString" providerName="System.Data.SqlClient" connectionString="connection string here" /> 
    </connectionStrings> 
    <system.web> 
     <roleManager defaultProvider="YourSqlRoleProvider" enabled="true"> 
      <providers> 
       <clear /> 
       <add name="YourSqlRoleProvider" type="YourSqlRoleProvider" connectionStringName="YourConnectionString" /> 
      </providers> 
     </roleManager> 
    </system.web> 
</configuration>