(no commit message)
[utils] / security / impl / src / main / java / org / wamblee / usermgt / UserAdministrationImpl.java
1 /*
2  * Copyright 2005-2010 the original author or authors.
3  * 
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  * 
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  * 
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */ 
16 package org.wamblee.usermgt;
17
18 import static org.wamblee.usermgt.UserMgtException.Reason.DUPLICATE_GROUP;
19 import static org.wamblee.usermgt.UserMgtException.Reason.DUPLICATE_USER;
20 import static org.wamblee.usermgt.UserMgtException.Reason.GROUP_STILL_OCCUPIED;
21 import static org.wamblee.usermgt.UserMgtException.Reason.TRIVIAL_RENAME;
22 import static org.wamblee.usermgt.UserMgtException.Reason.UNKNOWN_GROUP;
23 import static org.wamblee.usermgt.UserMgtException.Reason.UNKNOWN_USER;
24
25 import java.util.Set;
26
27 /**
28  * Administration of users and groups.
29  * 
30  * @author Erik Brakkee
31  */
32 public class UserAdministrationImpl implements UserAdministration {
33     /**
34      * All known users.
35      */
36     private UserSet users;
37
38     /**
39      * All known groups.
40      */
41     private GroupSet groups;
42
43     /**
44      * Validator for user names.
45      */
46     private NameValidator userValidator;
47
48     /**
49      * Validator for group names.
50      */
51     private NameValidator groupValidator;
52
53     /**
54      * Constructs empty user administration.
55      * 
56      */
57     public UserAdministrationImpl(UserSet aUsers, GroupSet aGroups,
58         NameValidator aUserValidator, NameValidator aGroupValidator) {
59         users = aUsers;
60         groups = aGroups;
61         userValidator = aUserValidator;
62         groupValidator = aGroupValidator;
63     }
64
65     /*
66      * (non-Javadoc)
67      * 
68      * @see org.wamblee.usermgt.UserAdministration#createUser(java.lang.String,
69      * java.lang.String)
70      */
71     public User createUser(String aUser, String aPassword, Group aGroup)
72         throws UserMgtException {
73         userValidator.validate(aUser);
74         checkGroup(aGroup);
75
76         User user = users.createUser(aUser, aPassword, aGroup);
77
78         return new User(user);
79     }
80
81     /*
82      * (non-Javadoc)
83      * 
84      * @see org.wamblee.usermgt.UserAdministration#createGroup(java.lang.String)
85      */
86     public Group createGroup(String aName) throws UserMgtException {
87         groupValidator.validate(aName);
88
89         Group group = new Group(aName);
90
91         if (groups.contains(group)) {
92             throw new UserMgtException(DUPLICATE_GROUP, group);
93         }
94
95         groups.add(group);
96
97         return new Group(group);
98     }
99
100     /*
101      * (non-Javadoc)
102      * 
103      * @see
104      * org.wamblee.usermgt.UserAdministration#userModified(org.wamblee.usermgt
105      * .User)
106      */
107     public void userModified(User aUser) {
108         users.userModified(aUser);
109     }
110
111     /*
112      * (non-Javadoc)
113      * 
114      * @see
115      * org.wamblee.usermgt.UserAdministration#groupModified(org.wamblee.usermgt
116      * .Group)
117      */
118     public void groupModified(Group aGroup) {
119         groups.groupModified(aGroup);
120     }
121
122     /*
123      * (non-Javadoc)
124      * 
125      * @see org.wamblee.usermgt.UserAdministration#getUser(java.lang.String)
126      */
127     public User getUser(String aName) {
128         return users.find(aName);
129     }
130
131     /*
132      * (non-Javadoc)
133      * 
134      * @see org.wamblee.usermgt.UserAdministration#getGroup(java.lang.String)
135      */
136     public Group getGroup(String aName) {
137         return groups.find(aName);
138     }
139
140     /*
141      * (non-Javadoc)
142      * 
143      * @see org.wamblee.usermgt.UserAdministration#getUsers()
144      */
145     public Set<User> getUsers() {
146         return users.list();
147     }
148
149     /*
150      * (non-Javadoc)
151      * 
152      * @see
153      * org.wamblee.usermgt.UserAdministration#getUsers(org.wamblee.usermgt.Group
154      * )
155      */
156     public Set<User> getUsers(Group aGroup) {
157         return users.list(aGroup);
158     }
159
160     /*
161      * (non-Javadoc)
162      * 
163      * @see org.wamblee.usermgt.UserAdministration#getGroups()
164      */
165     public Set<Group> getGroups() {
166         return groups.list();
167     }
168
169     /*
170      * (non-Javadoc)
171      * 
172      * @see
173      * org.wamblee.usermgt.UserAdministration#removeUser(org.wamblee.usermgt
174      * .User)
175      */
176     public void removeUser(User aUser) throws UserMgtException {
177         checkUser(aUser);
178         users.remove(aUser);
179     }
180
181     /*
182      * (non-Javadoc)
183      * 
184      * @see
185      * org.wamblee.usermgt.UserAdministration#removeGroup(org.wamblee.usermgt
186      * .Group)
187      */
188     public void removeGroup(Group aGroup) throws UserMgtException {
189         checkGroup(aGroup);
190
191         if (getUsers(aGroup).size() > 0) {
192             throw new UserMgtException(GROUP_STILL_OCCUPIED, aGroup);
193         }
194
195         groups.remove(aGroup);
196     }
197
198     /*
199      * (non-Javadoc)
200      * 
201      * @see
202      * org.wamblee.usermgt.UserAdministration#renameUser(org.wamblee.usermgt
203      * .User, java.lang.String)
204      */
205     public void renameUser(User aUser, String aUserName)
206         throws UserMgtException {
207         checkUser(aUser);
208
209         if (aUser.getName().equals(aUserName)) {
210             throw new UserMgtException(TRIVIAL_RENAME, aUser);
211         }
212
213         if (users.find(aUserName) != null) {
214             throw new UserMgtException(DUPLICATE_USER, aUser);
215         }
216
217         userValidator.validate(aUserName);
218         // we are modifying the user so we should re-insert it into the set
219         // after renaming it.
220         users.remove(aUser);
221         aUser.setName(aUserName);
222         users.add(aUser);
223     }
224
225     /*
226      * (non-Javadoc)
227      * 
228      * @see
229      * org.wamblee.usermgt.UserAdministration#renameGroup(org.wamblee.usermgt
230      * .Group, java.lang.String)
231      */
232     public void renameGroup(Group aGroup, String aGroupName)
233         throws UserMgtException {
234         checkGroup(aGroup);
235
236         if (aGroup.getName().equals(aGroupName)) {
237             throw new UserMgtException(TRIVIAL_RENAME, aGroup);
238         }
239
240         if (groups.find(aGroupName) != null) {
241             throw new UserMgtException(DUPLICATE_GROUP, aGroup);
242         }
243
244         groupValidator.validate(aGroupName);
245         // we are renaming the group so we should re-insert it into the set
246         // after renaming it.
247         groups.remove(aGroup);
248         aGroup.setName(aGroupName);
249         groups.add(aGroup);
250     }
251
252     /*
253      * (non-Javadoc)
254      * 
255      * @see
256      * org.wamblee.usermgt.UserAdministration#addUserToGroup(org.wamblee.usermgt
257      * .User, org.wamblee.usermgt.Group)
258      */
259     public void addUserToGroup(User aUser, Group aGroup)
260         throws UserMgtException {
261         checkUser(aUser);
262         checkGroup(aGroup);
263         aUser.addGroup(aGroup);
264         users.userModified(aUser);
265     }
266
267     /*
268      * (non-Javadoc)
269      * 
270      * @see
271      * org.wamblee.usermgt.UserAdministration#removeUserFromGroup(org.wamblee
272      * .usermgt.User, org.wamblee.usermgt.Group)
273      */
274     public void removeUserFromGroup(User aUser, Group aGroup)
275         throws UserMgtException {
276         checkUser(aUser);
277         checkGroup(aGroup);
278         aUser.removeGroup(aGroup);
279         users.userModified(aUser);
280     }
281
282     /**
283      * 
284      * @param aUser
285      * 
286      * @throws UserMgtException
287      */
288     private void checkUser(User aUser) throws UserMgtException {
289         if (!users.contains(aUser)) {
290             throw new UserMgtException(UNKNOWN_USER, aUser);
291         }
292     }
293
294     /**
295      * 
296      * @param aGroup
297      * 
298      * @throws UserMgtException
299      */
300     private void checkGroup(Group aGroup) throws UserMgtException {
301         if (!groups.contains(aGroup)) {
302             throw new UserMgtException(UNKNOWN_GROUP, aGroup);
303         }
304     }
305
306     /*
307      * (non-Javadoc)
308      * 
309      * @see org.wamblee.usermgt.UserAdministration#getUserCount()
310      */
311     public int getUserCount() {
312         return users.size();
313     }
314
315     /*
316      * (non-Javadoc)
317      * 
318      * @see org.wamblee.usermgt.UserAdministration#getGroupCount()
319      */
320     public int getGroupCount() {
321         return groups.size();
322     }
323 }