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 package info.magnolia.cms.security;
35
36 import info.magnolia.cms.security.auth.ACL;
37
38 import java.util.ArrayList;
39 import java.util.Collection;
40 import java.util.Map;
41
42 import javax.jcr.Value;
43 import javax.security.auth.Subject;
44
45
46
47
48
49
50
51 public class DelegatingUserManager implements UserManager {
52
53 private final Map<String, UserManager> delegates;
54
55
56
57
58 public DelegatingUserManager(Map<String, UserManager> delegates) {
59 this.delegates = delegates;
60 }
61
62 @Override
63 public User createUser(final String name, final String pw) throws UnsupportedOperationException {
64 final Op<User> op = new Op<User>() {
65 @Override
66 public User delegate(UserManager um) {
67 return um.createUser(name, pw);
68 }
69 };
70 return delegateUntilSupported(op);
71 }
72
73 @Override
74 public User createUser(final String path, final String name, final String pw) throws UnsupportedOperationException {
75 final Op<User> op = new Op<User>() {
76 @Override
77 public User delegate(UserManager um) {
78 return um.createUser(path, name, pw);
79 }
80 };
81 return delegateUntilSupported(op);
82 }
83
84 @Override
85 public User changePassword(User user, String newPassword) throws UnsupportedOperationException {
86 throw new UnsupportedOperationException("Please use a specific instance of UserManager to do this.");
87 }
88
89 @Override
90 public User getAnonymousUser() {
91 return delegateUntilSupported(new Op<User>() {
92 @Override
93 public User delegate(UserManager um) {
94 return um.getAnonymousUser();
95 }
96 });
97 }
98
99 @Override
100 public User getSystemUser() {
101 return delegateUntilSupported(new Op<User>() {
102 @Override
103 public User delegate(UserManager um) {
104 return um.getSystemUser();
105 }
106 });
107 }
108
109 @Override
110 public User getUser(final String name) throws UnsupportedOperationException {
111 return delegateUntilSupportedAndNotNull(new Op<User>() {
112 @Override
113 public User delegate(UserManager um) {
114 return um.getUser(name);
115 }
116 });
117 }
118
119 @Override
120 public User getUserById(final String id) throws UnsupportedOperationException {
121 return delegateUntilSupportedAndNotNull(new Op<User>() {
122 @Override
123 public User delegate(UserManager um) {
124 return um.getUserById(id);
125 }
126 });
127 }
128
129 @Override
130 public User getUser(final Subject subject) throws UnsupportedOperationException {
131 return delegateUntilSupportedAndNotNull(new Op<User>() {
132 @Override
133 public User delegate(UserManager um) {
134 return um.getUser(subject);
135 }
136 });
137 }
138
139 @Override
140 public Collection<User> getAllUsers() throws UnsupportedOperationException{
141 Collection<User> users = new ArrayList<User>();
142 for (String realmName : delegates.keySet()) {
143 try{
144 UserManager userManager = delegates.get(realmName);
145 users.addAll(userManager.getAllUsers());
146 }catch (UnsupportedOperationException e){
147
148 }
149 }
150 return users;
151 }
152
153 @Override
154 public void updateLastAccessTimestamp(final User user) {
155 delegateUntilSupported(new Op<Void>() {
156 @Override
157 public Void delegate(UserManager um) {
158 um.updateLastAccessTimestamp(user);
159 return null;
160 }
161 });
162 }
163
164 private <RT> RT delegateUntilSupported(Op<RT> op) {
165 for (String realmName : delegates.keySet()) {
166 final UserManager um = delegates.get(realmName);
167 try {
168 return op.delegate(um);
169 } catch (UnsupportedOperationException e) {
170
171 }
172 }
173 throw new UnsupportedOperationException("None of the delegate UserManager supports this operation.");
174 }
175
176 private <RT> RT delegateUntilNotNull(Op<RT> op) {
177 for (String realmName : delegates.keySet()) {
178 final UserManager um = delegates.get(realmName);
179 final RT result = op.delegate(um);
180 if (result != null) {
181 return result;
182 }
183 }
184 return null;
185 }
186
187 private <RT> RT delegateUntilSupportedAndNotNull(Op<RT> op) {
188 for (String realmName : delegates.keySet()) {
189 final UserManager um = delegates.get(realmName);
190 RT result = null;
191 try {
192 result = op.delegate(um);
193 } catch (UnsupportedOperationException e) {
194
195 }
196 if (result != null) {
197 return result;
198 }
199 }
200 return null;
201 }
202
203 private interface Op<RT> {
204 RT delegate(UserManager um);
205 }
206
207 @Override
208 public boolean hasAny(final String principal, final String resourceName, final String resourceTypeName) {
209 return delegateUntilSupported(new Op<Boolean>() {
210 @Override
211 public Boolean delegate(UserManager um) {
212 return um.hasAny(principal, resourceName, resourceTypeName);
213 }
214 });
215 }
216
217 @Override
218 public Map<String,ACL> getACLs(final User user) {
219 return delegateUntilSupported(new Op<Map<String,ACL>>() {
220 @Override
221 public Map<String,ACL> delegate(UserManager um) {
222 return um.getACLs(user);
223 }
224 });
225 }
226
227 @Override
228 public User addRole(final User user, final String roleName) {
229 return delegateUntilNotNull(new Op<User>() {
230 @Override
231 public User delegate(UserManager um) {
232 return um.addRole(user, roleName);
233 }
234 });
235 }
236
237 @Override
238 public User addGroup(final User user, final String groupName) {
239 return delegateUntilNotNull(new Op<User>() {
240 @Override
241 public User delegate(UserManager um) {
242 return um.addGroup(user, groupName);
243 }
244 });
245 }
246
247 @Override
248 public int getLockTimePeriod() throws UnsupportedOperationException {
249 return delegateUntilSupported(new Op<Integer>() {
250 @Override
251 public Integer delegate(UserManager userManager) {
252 return userManager.getLockTimePeriod();
253 }
254 });
255 }
256
257 @Override
258 public int getMaxFailedLoginAttempts() throws UnsupportedOperationException {
259 return delegateUntilSupported(new Op<Integer>() {
260 @Override
261 public Integer delegate(UserManager userManager) {
262 return userManager.getMaxFailedLoginAttempts();
263 }
264 });
265 }
266
267 @Override
268 public void setLockTimePeriod(final int lockTimePeriod) throws UnsupportedOperationException {
269 delegateUntilSupported(new Op<Void>() {
270 @Override
271 public Void delegate(UserManager userManager) {
272 userManager.setLockTimePeriod(lockTimePeriod);
273 return null;
274 }
275 });
276 }
277
278 @Override
279 public void setMaxFailedLoginAttempts(final int maxFailedLoginAttempts) throws UnsupportedOperationException {
280 delegateUntilSupported(new Op<Void>() {
281 @Override
282 public Void delegate(UserManager userManager) {
283 userManager.setMaxFailedLoginAttempts(maxFailedLoginAttempts);
284 return null;
285 }
286 });
287 }
288
289 @Override
290 public User setProperty(final User user, final String propertyName, final Value propertyValue) throws UnsupportedOperationException {
291 return delegateUntilSupported(new Op<User>() {
292 @Override
293 public User delegate(UserManager userManager) {
294 return userManager.setProperty(user, propertyName, propertyValue);
295 }
296 });
297 }
298
299 @Override
300 public User setProperty(final User user, final String propertyName, final String propertyValue) {
301 return delegateUntilSupported(new Op<User>() {
302 @Override
303 public User delegate(UserManager um) {
304 return um.setProperty(user, propertyName, propertyValue);
305 }
306 });
307 }
308
309 @Override
310 public User removeGroup(final User user, final String groupName) {
311 return delegateUntilNotNull(new Op<User>() {
312 @Override
313 public User delegate(UserManager um) {
314 return um.removeGroup(user, groupName);
315 }
316 });
317 }
318
319 @Override
320 public User removeRole(final User user, final String roleName) {
321 return delegateUntilNotNull(new Op<User>() {
322 @Override
323 public User delegate(UserManager um) {
324 return um.removeRole(user, roleName);
325 }
326 });
327 }
328 }