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.security.auth.Subject;
43 import javax.jcr.Value;
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 delegateUntilNotNull(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 delegateUntilNotNull(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 delegateUntilNotNull(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 interface Op<RT> {
177 RT delegate(UserManager um);
178 }
179
180 @Override
181 public boolean hasAny(final String principal, final String resourceName, final String resourceTypeName) {
182 return delegateUntilSupported(new Op<Boolean>() {
183 @Override
184 public Boolean delegate(UserManager um) {
185 return um.hasAny(principal, resourceName, resourceTypeName);
186 }
187 });
188 }
189
190 @Override
191 public Map<String,ACL> getACLs(final User user) {
192 return delegateUntilSupported(new Op<Map<String,ACL>>() {
193 @Override
194 public Map<String,ACL> delegate(UserManager um) {
195 return um.getACLs(user);
196 }
197 });
198 }
199
200 @Override
201 public User addRole(final User user, final String roleName) {
202 return delegateUntilNotNull(new Op<User>() {
203 @Override
204 public User delegate(UserManager um) {
205 return um.addRole(user, roleName);
206 }
207 });
208 }
209
210 @Override
211 public User addGroup(final User user, final String groupName) {
212 return delegateUntilNotNull(new Op<User>() {
213 @Override
214 public User delegate(UserManager um) {
215 return um.addGroup(user, groupName);
216 }
217 });
218 }
219
220 @Override
221 public int getLockTimePeriod() throws UnsupportedOperationException {
222 return delegateUntilSupported(new Op<Integer>() {
223 @Override
224 public Integer delegate(UserManager userManager) {
225 return userManager.getLockTimePeriod();
226 }
227 });
228 }
229
230 @Override
231 public int getMaxFailedLoginAttempts() throws UnsupportedOperationException {
232 return delegateUntilSupported(new Op<Integer>() {
233 @Override
234 public Integer delegate(UserManager userManager) {
235 return userManager.getMaxFailedLoginAttempts();
236 }
237 });
238 }
239
240 @Override
241 public void setLockTimePeriod(final int lockTimePeriod) throws UnsupportedOperationException {
242 delegateUntilSupported(new Op<Void>() {
243 @Override
244 public Void delegate(UserManager userManager) {
245 userManager.setLockTimePeriod(lockTimePeriod);
246 return null;
247 }
248 });
249 }
250
251 @Override
252 public void setMaxFailedLoginAttempts(final int maxFailedLoginAttempts) throws UnsupportedOperationException {
253 delegateUntilSupported(new Op<Void>() {
254 @Override
255 public Void delegate(UserManager userManager) {
256 userManager.setMaxFailedLoginAttempts(maxFailedLoginAttempts);
257 return null;
258 }
259 });
260 }
261
262 @Override
263 public User setProperty(final User user, final String propertyName, final Value propertyValue) throws UnsupportedOperationException {
264 return delegateUntilSupported(new Op<User>() {
265 @Override
266 public User delegate(UserManager userManager) {
267 return userManager.setProperty(user, propertyName, propertyValue);
268 }
269 });
270 }
271
272 @Override
273 public User removeGroup(final User user, final String groupName) {
274 return delegateUntilNotNull(new Op<User>() {
275 @Override
276 public User delegate(UserManager um) {
277 return um.removeGroup(user, groupName);
278 }
279 });
280 }
281
282 @Override
283 public User removeRole(final User user, final String roleName) {
284 return delegateUntilNotNull(new Op<User>() {
285 @Override
286 public User delegate(UserManager um) {
287 return um.removeRole(user, roleName);
288 }
289 });
290 }
291 }