Discussion :

[adurand]

Bonjour ;

Je me mets à C# et je réfléchis à la bascule d'une appli Web vers une winform en C#. Ma grosse interrogation est de savoir si on peut facilement gérer une appli multi-users avec des accès à des fonctionnalités en fonction de ses autorisations.

Est-ce que c'est possible facilement ou bien est-ce que je rêve

Merci de vos aiguillages ...

Aymeric

PS : si jamais c'est possible, si vous aviez des pistes de tuto

[theMonz31]

salut

c'est tout à fait possible

Multi User, tu veux dire plusieurs profils ?

Il suffit que tu es une base de données avec les utilisateurs, la notion de niveau d'utilisation dans ton application et ensuite, tu peux tres bien créer une classe qui gérera les autorisations d'acces aux données en fonction du privilège de tes utilisateurs

Rien à priori de compliqué

Maintenant, si tu précises ta question, je pourrais peut-etre t'en dire davantage

Pas de tuto sous la main, désolé

The Monz, Toulouse

[adurand]

Salut ;

L'idée serait d'avoir une application avec plusieurs groupes d'utilisateurs (responsable, leader et opé) et ensuite d'avoir une gestion des droits au niveau des groupes pour l'accès à des fonctionnalités.

Ma grosse question est de savoir les flux d'authentification possible avec une winform. Autant avec une appli web et des variables de session je le conçois bien mais avec une winform plus dur

L'application accèderait à une bdd access sur un serveur (sql ou mysql à moyen therme) depuis les postes clients. Donc un user se logue, on récupère son groupe et donc on sait ce qu'il a le droit de faire.

Merci en tout cas de ton aide ;

Aymeric

[The_badger_man]

Ma grosse question est de savoir les flux d'authentification possible avec une winform. Autant avec une appli web et des variables de session je le conçois bien mais avec une winform plus dur

Tu peux toujours faire une classe static avec des attributs et des méthodes static jouant le même rôle que les variables de sessions.

[Thomas Lebrun]

L'application accèderait à une bdd access sur un serveur (sql ou mysql à moyen therme) depuis les postes clients. Donc un user se logue, on récupère son groupe et donc on sait ce qu'il a le droit de faire.

C'est tout à fait possible


Imagine que tu créés un UserControl par niveau d'utilisateur (chaque UserControl peut faire ses propres actions): en fonction du groupe de ton user, tu charges le UserControl qui va bien

[philippe.cagnes]

voir mon post :
http://www.developpez.net/forums/d39...s/#post4093917

[shwin]

J'ai dévellopé, il y a pas longtemps, ce petit code qui permet de faire ce que tu souhaite mais avec de l'impersonalisation


J'ai tout dabord créé un realproxy pour intercepter mes appels

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
	[InterceptorProxy]
	public class ContextBoundController : ContextBoundObject
	{
		public ContextBoundController()
			: base()
		{
 
		}
	}
 
	public class InterceptorProxy : RealProxy
	{
		[System.Runtime.InteropServices.DllImport("advapi32.dll", SetLastError = true, CharSet = System.Runtime.InteropServices.CharSet.Unicode)]
		public static extern bool LogonUser(String lpszUsername, String lpszDomain, String lpszPassword,
				int dwLogonType, int dwLogonProvider, ref IntPtr phToken);
 
		private MarshalByRefObject m_realObject;
 
		public InterceptorProxy()
		{
 
		}
 
		public InterceptorProxy(Type classToProxy)
			: base(classToProxy)
		{
		}
 
		//private Dictionary<object, PrincipalPermissionAttribute> _securedMethods = new Dictionary<object,PrincipalPermissionAttribute>();
		//public Dictionary<object, PrincipalPermissionAttribute> SecuredMethods
		//{
		//  get { return _securedMethods; }
		//  set { _securedMethods = value; }
		//}
 
 
		public override IMessage Invoke(IMessage msg)
		{
			IMessage returnMessage = null;
 
			if (msg is IConstructionCallMessage)
			{
 
				IConstructionCallMessage ctorCallMessage = msg as IConstructionCallMessage;
 
				returnMessage = InitializeServerObject(ctorCallMessage);
 
				m_realObject = GetUnwrappedServer();
 
				SetStubData(this, m_realObject);
 
			}
 
			else if (msg is IMethodCallMessage)
			{
				IMethodCallMessage methodCallMessage = null;
				IMethodReturnMessage rawReturnMessage = null;
				methodCallMessage = msg as IMethodCallMessage;
				Preprocess(methodCallMessage);
 
 
				rawReturnMessage = RemotingServices.ExecuteMessage(m_realObject, methodCallMessage);
 
				if ((rawReturnMessage.Exception != null) && (rawReturnMessage.Exception.GetType()== typeof(SecurityException)))
				{
					DialogResult result = DialogResult.None;
					CredentialsDialog credentialsDialog = new CredentialsDialog("", "... authentication.");
					credentialsDialog.SaveDisplayed = false;
					credentialsDialog.Message = "Welcome to ...";
 
					const int LOGON32_PROVIDER_DEFAULT = 0;
					const int LOGON32_LOGON_INTERACTIVE = 2;
					IntPtr tokenHandle = new IntPtr(0);
					bool logged = false;
 
					do
					{
						result = credentialsDialog.Show();
						logged = LogonUser(credentialsDialog.Name, "domain.local", credentialsDialog.Password, LOGON32_LOGON_INTERACTIVE, LOGON32_PROVIDER_DEFAULT, ref tokenHandle);
 
						if (logged)
						{
							WindowsIdentity identity = new WindowsIdentity(tokenHandle);
							WindowsImpersonationContext context = identity.Impersonate();
							IPrincipal oldPrincipal = Thread.CurrentPrincipal;
							Thread.CurrentPrincipal = new WindowsPrincipal(identity);
 
							//Recall with impersonate
							rawReturnMessage = RemotingServices.ExecuteMessage(m_realObject, methodCallMessage);
							context.Undo();
							Thread.CurrentPrincipal = oldPrincipal;
						}
					}
					while ((result == DialogResult.OK && logged == false) || (logged && rawReturnMessage.Exception != null && rawReturnMessage.Exception.GetType() == typeof(SecurityException)));
 
					MessageBox.Show(logged.ToString());
					if (!logged)
						throw rawReturnMessage.Exception;
				}
				returnMessage = PostProcess(methodCallMessage, rawReturnMessage);
			}
			else
			{
				throw new NotSupportedException();
			}
 
			return returnMessage;
 
		}
 
		private void Preprocess(IMessage msg)
		{
			//if (SecuredMethods.ContainsKey(msg.Properties["__MethodName"]))
			//{
			//  PrincipalPermissionAttribute attr = SecuredMethods[msg.Properties["__MethodName"]];
			//  try
			//  {
			//    attr.CreatePermission().Demand();
			//  }
			//  catch (SecurityException ex)
			//  {
 
			//    throw;
			//  }
 
			//}
			// Do interception work here.
 
		}
 
 
 
		private IMessage PostProcess(IMessage msg, IMessage msgReturn)
		{
 
			// Do interception work here.
			return msgReturn;
		}
 
	}
 
	[AttributeUsage(AttributeTargets.Class)]
	[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.Infrastructure)]
	public class InterceptorProxyAttribute : ProxyAttribute
	{
 
		public InterceptorProxyAttribute()
		{
		}
 
		public override MarshalByRefObject CreateInstance(Type serverType)
		{
			RealProxy proxy = new InterceptorProxy(serverType);
			MarshalByRefObject transparentProxy = (MarshalByRefObject)proxy.GetTransparentProxy();
			return transparentProxy;
		}
 
	}

Ce code check les PrincipalPermissionAttribute (http://msdn.microsoft.com/en-us/libr...attribute.aspx), si le un securityException est levé, il "pop" le window credential de windows pour l'impersonalisation.

Le code n'est pas parfait mais fonctionne bien. C'est tjrs mieux que de créé un usercontrol par users\roles

P.S. Ya fallu que je désactive ce code dans mon application, CAB (http://www.microsoft.com/Downloads/d...displaylang=en) a cause que le CAB aime bien le merveilleux FormatterServices.GetSafeUninitializedObject. Qqn a déja utiliser le ContextBoundObject et le FormatterServices ?

[Bluedeep]

Il suffit que tu es une base de données avec les utilisateurs, la notion de niveau d'utilisation dans ton application et ensuite, tu peux tres bien créer une classe qui gérera les autorisations d'acces aux données en fonction du privilège de tes utilisateurs

Même pas nécessaire : il peut très bien utiliser des groupes Windows spécifiques et controler l'appartenance du login Windows aux groupes en question.
Cela simplifie les choses si tu dois faire intéragir des utilisateurs avec d'autres appli qui n'ont pas forcément connaissance de la structuration de tes droits et a fortiori de ta base de données.
Et dans tous les cas ,c'est plus élégant