wamblee.org Git - utils/blob - security/impl/src/main/java/org/wamblee/security/authentication/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.security.authentication;
  17
  18 import static org.wamblee.security.authentication.UserMgtException.Reason.*;
  19
  20 import java.util.ArrayList;
  21 import java.util.List;
  22
  23 import org.wamblee.security.authentication.UserMgtException.Reason;
  24
  25 /**
  26  * Administration of users and groups.
  27  *
  28  * @author Erik Brakkee
  29  */
  30 public class UserAdministrationImpl implements UserAdministration {
  31     /**
  32      * All known users.
  33      */
  34     private UserSet users;
  35
  36     /**
  37      * All known groups.
  38      */
  39     private GroupSet groups;
  40
  41     /**
  42      * Validator for user names.
  43      */
  44     private NameValidator userValidator;
  45
  46     /**
  47      * Validator for group names.
  48      */
  49     private NameValidator groupValidator;
  50
  51     /**
  52      * Constructs empty user administration.
  53      *
  54      */
  55     public UserAdministrationImpl(UserSet aUsers, GroupSet aGroups,
  56         NameValidator aUserValidator, NameValidator aGroupValidator) {
  57         users = aUsers;
  58         groups = aGroups;
  59         userValidator = aUserValidator;
  60         groupValidator = aGroupValidator;
  61     }
  62
  63     /*
  64      * (non-Javadoc)
  65      *
  66      * @see org.wamblee.usermgt.UserAdministration#createUser(java.lang.String,
  67      * java.lang.String)
  68      */
  69     @Override
  70     public void createUser(String aUser, String aPassword) {
  71         if (!userValidator.validate(aUser)) {
  72             throw new UserMgtException(Reason.INVALID_USERNAME, aUser);
  73         }
  74
  75         users.createUser(aUser, aPassword);
  76     }
  77
  78     /*
  79      * (non-Javadoc)
  80      *
  81      * @see org.wamblee.usermgt.UserAdministration#createGroup(java.lang.String)
  82      */
  83     @Override
  84     public void createGroup(String aName) {
  85         if (!groupValidator.validate(aName)) {
  86             throw new UserMgtException(Reason.INVALID_GROUPNAME, aName);
  87         }
  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
  98     @Override
  99     public boolean checkUser(String aUser) {
 100         return users.find(aUser) != null;
 101     }
 102
 103     @Override
 104     public boolean checkGroup(String aGroup) {
 105         return groups.find(aGroup) != null;
 106     }
 107
 108     @Override
 109     public boolean checkPassword(String aUser, String aPassword) {
 110         User user = requireUser(aUser, "While checking password");
 111         return user.checkPassword(aPassword);
 112     }
 113
 114     private User requireUser(String aUser, String aMsg) {
 115         User user = users.find(aUser);
 116         if (user == null) {
 117             throw new UserMgtException(Reason.UNKNOWN_USER, aMsg);
 118         }
 119         return user;
 120     }
 121
 122     private Group requireGroup(String aGroup, String aMsg) {
 123         Group group = groups.find(aGroup);
 124         if (group == null) {
 125             throw new UserMgtException(Reason.UNKNOWN_GROUP, aMsg);
 126         }
 127         return group;
 128     }
 129
 130     @Override
 131     public boolean changePassword(String aUser, String aOldPassword,
 132         String aNewPassword) {
 133         User user = requireUser(aUser, "While checking password");
 134         boolean res = user.changePassword(aOldPassword, aNewPassword);
 135         users.userModified(user);
 136         return res;
 137     }
 138
 139     @Override
 140     public void setPassword(String aUser, String aPassword) {
 141         User user = requireUser(aUser, "While setting password");
 142         user.setPassword(aPassword);
 143         users.userModified(user);
 144     }
 145
 146     @Override
 147     public boolean isInGroup(String aUser, String aGroup) {
 148         User user = requireUser(aUser,
 149             "While checking whether user belongs to group");
 150         return user.isInGroup(aGroup);
 151     }
 152
 153     @Override
 154     public int getUserCount() {
 155         return users.size();
 156     }
 157
 158     @Override
 159     public int getGroupCount() {
 160         return groups.size();
 161     }
 162
 163     @Override
 164     public List<String> getUsers() {
 165         List<String> res = new ArrayList<String>();
 166         for (User user : users.list()) {
 167             res.add(user.getName());
 168         }
 169         return res;
 170     }
 171
 172     @Override
 173     public List<String> getUsers(String aGroup) {
 174         Group group = requireGroup(aGroup, "While finding users for group");
 175         List<String> res = new ArrayList<String>();
 176         for (User user : users.list(group)) {
 177             res.add(user.getName());
 178         }
 179         return res;
 180     }
 181
 182     @Override
 183     public List<String> getGroups() {
 184         List<String> res = new ArrayList<String>();
 185         for (Group group : groups.list()) {
 186             res.add(group.getName());
 187         }
 188         return res;
 189     }
 190
 191     @Override
 192     public List<String> getGroups(String aUser) {
 193         User user = requireUser(aUser, "While getting list of groups");
 194         List<String> res = new ArrayList<String>();
 195         for (Group g : user.getGroups()) {
 196             res.add(g.getName());
 197         }
 198         return res;
 199     }
 200
 201     @Override
 202     public void renameUser(String aOldUsername, String aNewUsername) {
 203         User user = requireUser(aOldUsername, "While renaming user");
 204
 205         if (aOldUsername.equals(aNewUsername)) {
 206             return; // nothing to do.
 207         }
 208
 209         if (users.find(aNewUsername) != null) {
 210             throw new UserMgtException(DUPLICATE_USER, aNewUsername);
 211         }
 212
 213         if (!userValidator.validate(aNewUsername)) {
 214             throw new UserMgtException(Reason.INVALID_USERNAME, aNewUsername);
 215         }
 216
 217         user.setName(aNewUsername);
 218         users.userModified(user);
 219     }
 220
 221     @Override
 222     public void renameGroup(String aOldGroup, String aNewGroup) {
 223         Group group = requireGroup(aOldGroup, "While renaming group");
 224
 225         if (aOldGroup.equals(aNewGroup)) {
 226             return; // OK.
 227         }
 228
 229         if (groups.find(aNewGroup) != null) {
 230             throw new UserMgtException(DUPLICATE_GROUP, aNewGroup);
 231         }
 232
 233         if (!groupValidator.validate(aNewGroup)) {
 234             throw new UserMgtException(Reason.INVALID_GROUPNAME, aNewGroup);
 235         }
 236
 237         group.setName(aNewGroup);
 238         groups.groupModified(group);
 239         // Because a group has changed, a cached user could contain reference to an old copy of the
 240         // group. Therefore, we clear the cache in this case.
 241         users.clearCache();
 242     }
 243
 244     @Override
 245     public void removeUser(String aUser) {
 246         User user = requireUser(aUser, "While removing user");
 247         boolean removed = users.remove(user);
 248         if (!removed) {
 249             throw new UserMgtException(Reason.UNKNOWN_USER, aUser);
 250         }
 251     }
 252
 253     @Override
 254     public void removeGroup(String aGroup) {
 255         Group group = requireGroup(aGroup, "While removing group");
 256
 257         if (getUsers(aGroup).size() > 0) {
 258             throw new UserMgtException(GROUP_STILL_OCCUPIED, aGroup);
 259         }
 260
 261         boolean removed = groups.remove(group);
 262         if (!removed) {
 263             throw new UserMgtException(Reason.UNKNOWN_GROUP, aGroup);
 264         }
 265     }
 266
 267     @Override
 268     public void addUserToGroup(String aUser, String aGroup) {
 269         User user = requireUser(aUser, "While adding user to group");
 270         Group group = requireGroup(aGroup, "While adding user to group");
 271         user.addGroup(group);
 272         users.userModified(user);
 273     }
 274
 275     @Override
 276     public void removeUserFromGroup(String aUser, String aGroup) {
 277         User user = requireUser(aUser, "While removing user from group");
 278         Group group = requireGroup(aGroup, "While removing user from group");
 279         user.removeGroup(group);
 280         users.userModified(user);
 281     }
 282 }