wamblee.org Git - utils/blob - security/src/main/java/org/wamblee/usermgt/UserAdministrationImpl.java

   1 /*
   2  * Copyright 2005 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 /**
  29  * Administration of users and groups.
  30  *
  31  * @author Erik Brakkee
  32  */
  33 public class UserAdministrationImpl implements UserAdministration {
  34     /**
  35      * All known users.
  36      */
  37     private UserSet users;
  38
  39     /**
  40      * All known groups.
  41      */
  42     private GroupSet groups;
  43
  44     /**
  45      * Validator for user names.
  46      */
  47     private NameValidator userValidator;
  48
  49     /**
  50      * Validator for group names.
  51      */
  52     private NameValidator groupValidator;
  53
  54 /**
  55      * Constructs empty user administration.
  56      *
  57      */
  58     public UserAdministrationImpl(UserSet aUsers, GroupSet aGroups,
  59         NameValidator aUserValidator, NameValidator aGroupValidator) {
  60         users              = aUsers;
  61         groups             = aGroups;
  62         userValidator      = aUserValidator;
  63         groupValidator     = aGroupValidator;
  64     }
  65
  66     /*
  67      * (non-Javadoc)
  68      *
  69      * @see org.wamblee.usermgt.UserAdministration#createUser(java.lang.String,
  70      *      java.lang.String)
  71      */
  72     /**
  73      * DOCUMENT ME!
  74      *
  75      * @param aUser DOCUMENT ME!
  76      * @param aPassword DOCUMENT ME!
  77      * @param aGroup DOCUMENT ME!
  78      *
  79      * @return DOCUMENT ME!
  80      *
  81      * @throws UserMgtException DOCUMENT ME!
  82      */
  83     public User createUser(String aUser, String aPassword, Group aGroup)
  84         throws UserMgtException {
  85         userValidator.validate(aUser);
  86         checkGroup(aGroup);
  87
  88         User user = users.createUser(aUser, aPassword, aGroup);
  89
  90         return new User(user);
  91     }
  92
  93     /*
  94      * (non-Javadoc)
  95      *
  96      * @see org.wamblee.usermgt.UserAdministration#createGroup(java.lang.String)
  97      */
  98     /**
  99      * DOCUMENT ME!
 100      *
 101      * @param aName DOCUMENT ME!
 102      *
 103      * @return DOCUMENT ME!
 104      *
 105      * @throws UserMgtException DOCUMENT ME!
 106      */
 107     public Group createGroup(String aName) throws UserMgtException {
 108         groupValidator.validate(aName);
 109
 110         Group group = new Group(aName);
 111
 112         if (groups.contains(group)) {
 113             throw new UserMgtException(DUPLICATE_GROUP, group);
 114         }
 115
 116         groups.add(group);
 117
 118         return new Group(group);
 119     }
 120
 121     /*
 122      * (non-Javadoc)
 123      *
 124      * @see org.wamblee.usermgt.UserAdministration#userModified(org.wamblee.usermgt.User)
 125      */
 126     /**
 127      * DOCUMENT ME!
 128      *
 129      * @param aUser DOCUMENT ME!
 130      */
 131     public void userModified(User aUser) {
 132         users.userModified(aUser);
 133     }
 134
 135     /*
 136      * (non-Javadoc)
 137      *
 138      * @see org.wamblee.usermgt.UserAdministration#groupModified(org.wamblee.usermgt.Group)
 139      */
 140     /**
 141      * DOCUMENT ME!
 142      *
 143      * @param aGroup DOCUMENT ME!
 144      */
 145     public void groupModified(Group aGroup) {
 146         groups.groupModified(aGroup);
 147     }
 148
 149     /*
 150      * (non-Javadoc)
 151      *
 152      * @see org.wamblee.usermgt.UserAdministration#getUser(java.lang.String)
 153      */
 154     /**
 155      * DOCUMENT ME!
 156      *
 157      * @param aName DOCUMENT ME!
 158      *
 159      * @return DOCUMENT ME!
 160      */
 161     public User getUser(String aName) {
 162         return users.find(aName);
 163     }
 164
 165     /*
 166      * (non-Javadoc)
 167      *
 168      * @see org.wamblee.usermgt.UserAdministration#getGroup(java.lang.String)
 169      */
 170     /**
 171      * DOCUMENT ME!
 172      *
 173      * @param aName DOCUMENT ME!
 174      *
 175      * @return DOCUMENT ME!
 176      */
 177     public Group getGroup(String aName) {
 178         return groups.find(aName);
 179     }
 180
 181     /*
 182      * (non-Javadoc)
 183      *
 184      * @see org.wamblee.usermgt.UserAdministration#getUsers()
 185      */
 186     /**
 187      * DOCUMENT ME!
 188      *
 189      * @return DOCUMENT ME!
 190      */
 191     public Set<User> getUsers() {
 192         return users.list();
 193     }
 194
 195     /*
 196      * (non-Javadoc)
 197      *
 198      * @see org.wamblee.usermgt.UserAdministration#getUsers(org.wamblee.usermgt.Group)
 199      */
 200     /**
 201      * DOCUMENT ME!
 202      *
 203      * @param aGroup DOCUMENT ME!
 204      *
 205      * @return DOCUMENT ME!
 206      */
 207     public Set<User> getUsers(Group aGroup) {
 208         return users.list(aGroup);
 209     }
 210
 211     /*
 212      * (non-Javadoc)
 213      *
 214      * @see org.wamblee.usermgt.UserAdministration#getGroups()
 215      */
 216     /**
 217      * DOCUMENT ME!
 218      *
 219      * @return DOCUMENT ME!
 220      */
 221     public Set<Group> getGroups() {
 222         return groups.list();
 223     }
 224
 225     /*
 226      * (non-Javadoc)
 227      *
 228      * @see org.wamblee.usermgt.UserAdministration#removeUser(org.wamblee.usermgt.User)
 229      */
 230     /**
 231      * DOCUMENT ME!
 232      *
 233      * @param aUser DOCUMENT ME!
 234      *
 235      * @throws UserMgtException DOCUMENT ME!
 236      */
 237     public void removeUser(User aUser) throws UserMgtException {
 238         checkUser(aUser);
 239         users.remove(aUser);
 240     }
 241
 242     /*
 243      * (non-Javadoc)
 244      *
 245      * @see org.wamblee.usermgt.UserAdministration#removeGroup(org.wamblee.usermgt.Group)
 246      */
 247     /**
 248      * DOCUMENT ME!
 249      *
 250      * @param aGroup DOCUMENT ME!
 251      *
 252      * @throws UserMgtException DOCUMENT ME!
 253      */
 254     public void removeGroup(Group aGroup) throws UserMgtException {
 255         checkGroup(aGroup);
 256
 257         if (getUsers(aGroup).size() > 0) {
 258             throw new UserMgtException(GROUP_STILL_OCCUPIED, aGroup);
 259         }
 260
 261         groups.remove(aGroup);
 262     }
 263
 264     /*
 265      * (non-Javadoc)
 266      *
 267      * @see org.wamblee.usermgt.UserAdministration#renameUser(org.wamblee.usermgt.User,
 268      *      java.lang.String)
 269      */
 270     /**
 271      * DOCUMENT ME!
 272      *
 273      * @param aUser DOCUMENT ME!
 274      * @param aUserName DOCUMENT ME!
 275      *
 276      * @throws UserMgtException DOCUMENT ME!
 277      */
 278     public void renameUser(User aUser, String aUserName)
 279         throws UserMgtException {
 280         checkUser(aUser);
 281
 282         if (aUser.getName().equals(aUserName)) {
 283             throw new UserMgtException(TRIVIAL_RENAME, aUser);
 284         }
 285
 286         if (users.find(aUserName) != null) {
 287             throw new UserMgtException(DUPLICATE_USER, aUser);
 288         }
 289
 290         userValidator.validate(aUserName);
 291         // we are modifying the user so we should re-insert it into the set
 292         // after renaming it.
 293         users.remove(aUser);
 294         aUser.setName(aUserName);
 295         users.add(aUser);
 296     }
 297
 298     /*
 299      * (non-Javadoc)
 300      *
 301      * @see org.wamblee.usermgt.UserAdministration#renameGroup(org.wamblee.usermgt.Group,
 302      *      java.lang.String)
 303      */
 304     /**
 305      * DOCUMENT ME!
 306      *
 307      * @param aGroup DOCUMENT ME!
 308      * @param aGroupName DOCUMENT ME!
 309      *
 310      * @throws UserMgtException DOCUMENT ME!
 311      */
 312     public void renameGroup(Group aGroup, String aGroupName)
 313         throws UserMgtException {
 314         checkGroup(aGroup);
 315
 316         if (aGroup.getName().equals(aGroupName)) {
 317             throw new UserMgtException(TRIVIAL_RENAME, aGroup);
 318         }
 319
 320         if (groups.find(aGroupName) != null) {
 321             throw new UserMgtException(DUPLICATE_GROUP, aGroup);
 322         }
 323
 324         groupValidator.validate(aGroupName);
 325         // we are renaming the group so we should re-insert it into the set
 326         // after renaming it.
 327         groups.remove(aGroup);
 328         aGroup.setName(aGroupName);
 329         groups.add(aGroup);
 330     }
 331
 332     /*
 333      * (non-Javadoc)
 334      *
 335      * @see org.wamblee.usermgt.UserAdministration#addUserToGroup(org.wamblee.usermgt.User,
 336      *      org.wamblee.usermgt.Group)
 337      */
 338     /**
 339      * DOCUMENT ME!
 340      *
 341      * @param aUser DOCUMENT ME!
 342      * @param aGroup DOCUMENT ME!
 343      *
 344      * @throws UserMgtException DOCUMENT ME!
 345      */
 346     public void addUserToGroup(User aUser, Group aGroup)
 347         throws UserMgtException {
 348         checkUser(aUser);
 349         checkGroup(aGroup);
 350         aUser.addGroup(aGroup);
 351         users.userModified(aUser);
 352     }
 353
 354     /*
 355      * (non-Javadoc)
 356      *
 357      * @see org.wamblee.usermgt.UserAdministration#removeUserFromGroup(org.wamblee.usermgt.User,
 358      *      org.wamblee.usermgt.Group)
 359      */
 360     /**
 361      * DOCUMENT ME!
 362      *
 363      * @param aUser DOCUMENT ME!
 364      * @param aGroup DOCUMENT ME!
 365      *
 366      * @throws UserMgtException DOCUMENT ME!
 367      */
 368     public void removeUserFromGroup(User aUser, Group aGroup)
 369         throws UserMgtException {
 370         checkUser(aUser);
 371         checkGroup(aGroup);
 372         aUser.removeGroup(aGroup);
 373         users.userModified(aUser);
 374     }
 375
 376     /**
 377      * DOCUMENT ME!
 378      *
 379      * @param aUser
 380      *
 381      * @throws UserMgtException
 382      */
 383     private void checkUser(User aUser) throws UserMgtException {
 384         if (!users.contains(aUser)) {
 385             throw new UserMgtException(UNKNOWN_USER, aUser);
 386         }
 387     }
 388
 389     /**
 390      * DOCUMENT ME!
 391      *
 392      * @param aGroup
 393      *
 394      * @throws UserMgtException
 395      */
 396     private void checkGroup(Group aGroup) throws UserMgtException {
 397         if (!groups.contains(aGroup)) {
 398             throw new UserMgtException(UNKNOWN_GROUP, aGroup);
 399         }
 400     }
 401
 402     /* (non-Javadoc)
 403      * @see org.wamblee.usermgt.UserAdministration#getUserCount()
 404      */
 405     /**
 406      * DOCUMENT ME!
 407      *
 408      * @return DOCUMENT ME!
 409      */
 410     public int getUserCount() {
 411         return users.size();
 412     }
 413
 414     /* (non-Javadoc)
 415      * @see org.wamblee.usermgt.UserAdministration#getGroupCount()
 416      */
 417     /**
 418      * DOCUMENT ME!
 419      *
 420      * @return DOCUMENT ME!
 421      */
 422     public int getGroupCount() {
 423         return groups.size();
 424     }
 425 }