[C#] Conception - Utilisateur

[topolino]

Bonjour,

J'ai besoin de votre avis pour savoir si je vais bien dans la bonne direction.
Voila, j'ai 3 types d'utilisateur (SimpleUser, ClientUser, AdminUser) dans mon application avec des action differentes, et cela est determiné au login de la personne.

SimpleUser peut lire les infos
ClientUser peut lire et ecrire les infos
AdminUser peut lire, ecrire et effacer les infos

Voila ce que je propose dans mon domain model de ma couche business:

Enum User

Code :

1
2
3
4
5
6
7
 
    public enum UserType
    {
        SimpleUser = 0,
        ClientUser = 1,
        AdminUser = 2
    }

interface IUser

Code :

1
2
3
4
5
6
7
8
9
 
public interface IUser
    {
        int Id { get; set; }
        string Name { get; set; }
        void ReadInfo();
        void WriteInfo();
        void DeleteInfo();
    }

User

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
public class User : IUser
    {
 
        public int Id { get; set; }
        public string Name { get; set; }
 
        public User(string name)
        {
            Name = name;
        }
 
        public virtual void ReadInfo()
        {
            string myCode = "Code Here: I can read";
        }
 
        public virtual void WriteInfo()
        {
        }
 
        public virtual void DeleteInfo()
        {
        }
    }

SimpleUser

Code :

1
2
3
4
5
 
public class SimpleUser : User
    {
 
    }

ClientUser

Code :

1
2
3
4
5
6
7
8
9
10
11
12
 
 public class ClientUser: User
    {
        public ClientUser(string name)
            : base(name)
        { }
 
        public override void WriteInfo()
        {
            string myCode = "Code Here: I can write";
        }
    }

AdminUser

Code :

1
2
3
4
5
6
7
8
9
10
 
 class AdminUser: ClientUser
    {
        public AdminUser(string name) : base(name) { }
 
        public override void DeleteInfo()
        {
            string myCode = "Code Here: I can delete";
        }
    }

NullUser

Code :

1
2
3
4
5
6
7
8
 
    public class NullUser : User
    {
        public override void ReadInfo()
        {
 
        }
    }

User Repository

Code :

1
2
3
4
5
 
    public interface IUserRepository
    {
        UserType LogIn(string userName);
    }

UserFactory

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
    public static class UserFactory
    {
        public static IUser GetUserStrategyFor(UserType userType, string name)
        {
            switch (userType)
            {
                case UserType.SimpleUser:
                    return new User(name);
                case UserType.ClientUser:
                    return new ClientUser(name);
                case UserType.AdminUser:
                    return new AdminUser(name);
                default:
                    return new NullUser();
            }
        }
    }

UserService

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
    public class UserService
    {
        private IUserRepository _userRepository;
 
        public UserService(IUserRepository userRepository)
        {
            _userRepository = userRepository;
        }
 
        public IUser GetUser()
        {
            UserType userType = _userRepository.LogIn("test");
 
            IUser user = UserFactory.GetUserStrategyFor(userType, "test");
 
            return user;
        }    
    }

Merci pour vos conseils.

[BenoitM]

euh moi je ferai pas comme ca.

Je mettrai dans User une variable de type UserType

et dans les fonction Read,Delete je regarderait si le User a le level suffisant

[meziantou]

Pourquoi ne pas utiliser l'attribut PrincipalPermissionAttribute
http://msdn.microsoft.com/fr-fr/library/k8b3sz1a.aspx

Code :

1
2
[PrincipalPermission(SecurityAction.Demand, Role = 'AdminUser')]
void MyMethod(){}