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 getUser(final Subject subject) throws UnsupportedOperationException {
110 return delegateUntilNotNull(new Op<User>() {
111 @Override
112 public User delegate(UserManager um) {
113 return um.getUser(subject);
114 }
115 });
116 }
117
118 @Override
119 public Collection<User> getAllUsers() throws UnsupportedOperationException{
120 Collection<User> users = new ArrayList<User>();
121 for (String realmName : delegates.keySet()) {
122 try{
123 UserManager userManager = delegates.get(realmName);
124 users.addAll(userManager.getAllUsers());
125 }catch (UnsupportedOperationException e){
126
127 }
128 }
129 return users;
130 }
131
132 @Override
133 public void updateLastAccessTimestamp(final User user) {
134 delegateUntilSupported(new Op<Void>() {
135 @Override
136 public Void delegate(UserManager um) {
137 um.updateLastAccessTimestamp(user);
138 return null;
139 }
140 });
141 }
142
143 private <RT> RT delegateUntilSupported(Op<RT> op) {
144 for (String realmName : delegates.keySet()) {
145 final UserManager um = delegates.get(realmName);
146 try {
147 return op.delegate(um);
148 } catch (UnsupportedOperationException e) {
149
150 }
151 }
152 throw new UnsupportedOperationException("None of the delegate UserManager supports this operation.");
153 }
154
155 private <RT> RT delegateUntilNotNull(Op<RT> op) {
156 for (String realmName : delegates.keySet()) {
157 final UserManager um = delegates.get(realmName);
158 final RT result = op.delegate(um);
159 if (result != null) {
160 return result;
161 }
162 }
163 return null;
164 }
165
166 private interface Op<RT> {
167 RT delegate(UserManager um);
168 }
169
170 @Override
171 public boolean hasAny(final String principal, final String resourceName, final String resourceTypeName) {
172 return delegateUntilSupported(new Op<Boolean>() {
173 @Override
174 public Boolean delegate(UserManager um) {
175 return um.hasAny(principal, resourceName, resourceTypeName);
176 }
177 });
178 }
179
180 @Override
181 public Map<String,ACL> getACLs(final User user) {
182 return delegateUntilSupported(new Op<Map<String,ACL>>() {
183 @Override
184 public Map<String,ACL> delegate(UserManager um) {
185 return um.getACLs(user);
186 }
187 });
188 }
189
190 @Override
191 public User addRole(final User user, final String roleName) {
192 return delegateUntilNotNull(new Op<User>() {
193 @Override
194 public User delegate(UserManager um) {
195 return um.addRole(user, roleName);
196 }
197 });
198 }
199
200 @Override
201 public User addGroup(final User user, final String groupName) {
202 return delegateUntilNotNull(new Op<User>() {
203 @Override
204 public User delegate(UserManager um) {
205 return um.addGroup(user, groupName);
206 }
207 });
208 }
209
210 @Override
211 public int getLockTimePeriod() throws UnsupportedOperationException {
212 return delegateUntilSupported(new Op<Integer>() {
213 @Override
214 public Integer delegate(UserManager userManager) {
215 return userManager.getLockTimePeriod();
216 }
217 });
218 }
219
220 @Override
221 public int getMaxFailedLoginAttempts() throws UnsupportedOperationException {
222 return delegateUntilSupported(new Op<Integer>() {
223 @Override
224 public Integer delegate(UserManager userManager) {
225 return userManager.getMaxFailedLoginAttempts();
226 }
227 });
228 }
229
230 @Override
231 public void setLockTimePeriod(final int lockTimePeriod) throws UnsupportedOperationException {
232 delegateUntilSupported(new Op<Void>() {
233 @Override
234 public Void delegate(UserManager userManager) {
235 userManager.setLockTimePeriod(lockTimePeriod);
236 return null;
237 }
238 });
239 }
240
241 @Override
242 public void setMaxFailedLoginAttempts(final int maxFailedLoginAttempts) throws UnsupportedOperationException {
243 delegateUntilSupported(new Op<Void>() {
244 @Override
245 public Void delegate(UserManager userManager) {
246 userManager.setMaxFailedLoginAttempts(maxFailedLoginAttempts);
247 return null;
248 }
249 });
250 }
251
252 @Override
253 public User setProperty(final User user, final String propertyName, final Value propertyValue) throws UnsupportedOperationException {
254 return delegateUntilSupported(new Op<User>() {
255 @Override
256 public User delegate(UserManager userManager) {
257 return userManager.setProperty(user, propertyName, propertyValue);
258 }
259 });
260 }
261
262 @Override
263 public User removeGroup(final User user, final String groupName) {
264 return delegateUntilSupported(new Op<User>() {
265 @Override
266 public User delegate(UserManager um) {
267 return um.removeGroup(user, groupName);
268 }
269 });
270 }
271
272 @Override
273 public User removeRole(final User user, final String roleName) {
274 return delegateUntilSupported(new Op<User>() {
275 @Override
276 public User delegate(UserManager um) {
277 return um.removeRole(user, roleName);
278 }
279 });
280 }
281 }