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