wamblee.org Git - utils/blob - security/usermgt/src/main/java/org/wamblee/security/authentication/UserAdministration.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 java.util.List;
  19
  20 /**
  21  * Interface for user administration. Manages the users and groups.
  22  *
  23  * @author Erik Brakkee
  24  */
  25 public interface UserAdministration {
  26     /**
  27      * Creates a new user.
  28      *
  29      * @param aUser
  30      *            Username.
  31      * @param aPassword
  32      *            Password.
  33      *
  34      * @return User.
  35      *
  36      * @throws UserMgtException
  37      *             In case there is a conflict with an existing user.
  38      */
  39     void createUser(String aUser, String aPassword);
  40
  41     /**
  42      * Creates a new group.
  43      *
  44      * @param aName
  45      *            Group name.
  46      *
  47      * @return Group
  48      *
  49      * @throws UserMgtException
  50      *             In case there is a conflict with an existing group.
  51      */
  52     void createGroup(String aName);
  53
  54     /**
  55      * Checks if a user exists.
  56      * @param aUser User to check.
  57      * @return True iff user exists.
  58      */
  59     boolean checkUser(String aUser);
  60
  61
  62     /**
  63      * Check if a group exists.
  64      * @param aGroup Group.
  65      * @return True iff group exists.
  66      */
  67     boolean checkGroup(String aGroup);
  68
  69     /**
  70      * Checks the password.
  71      *
  72      * @param aUser
  73      *            User to check password for.
  74      * @param aPassword
  75      *            Password to check.
  76      * @throws UserMgtException In case user does not exist.
  77      * @return True iff password is ok.
  78      */
  79     boolean checkPassword(String aUser, String aPassword);
  80
  81     /**
  82      * Changes the password.
  83      *
  84      * @param aUser
  85      *            User.
  86      * @param aOldPassword
  87      *            Old password.
  88      * @param aNewPassword
  89      *            New password.
  90      *
  91      * @throws UserMgtException Inc ase the user does not exist.
  92      * @return True if the password was changed.
  93      */
  94     boolean changePassword(String aUser, String aOldPassword, String aNewPassword);
  95
  96     /**
  97      *
  98      * @param aUser
  99      *            User.
 100      * @param aPassword
 101      *            The password to set.
 102      *
 103      * @throws UserMgtException Inc ase the user does not exist.
 104      */
 105     void setPassword(String aUser, String aPassword);
 106
 107     /**
 108      * Checks if the user belongs to the given group.
 109      * @param aUser User
 110      * @param aGroup Group.
 111      * @return True iff user is in group
 112      * @throws UserMgtException In case the user or group do not exist.
 113      */
 114     boolean isInGroup(String aUser, String aGroup);
 115
 116     /**
 117      *
 118      * @return Number of users.
 119      */
 120     int getUserCount();
 121
 122     /**
 123      *
 124      * @return Number of groups.
 125      */
 126     int getGroupCount();
 127
 128     /**
 129      * Get the users.
 130      *
 131      * @return All known users.
 132      */
 133     List<String> getUsers();
 134
 135     /**
 136      * Gets the users for a given group.
 137      *
 138      * @param aGroup
 139      *            Group.
 140      * @return Set of users (always non-null).
 141      */
 142     List<String> getUsers(String aGroup);
 143
 144     /**
 145      * Gets all groups.
 146      *
 147      * @return Groups.
 148      */
 149     List<String> getGroups();
 150
 151     /**
 152      * Gets all groups for a given user.
 153      *
 154      * @param aUser user.
 155      * @return Groups.
 156      */
 157     List<String> getGroups(String aUser);
 158
 159     /**
 160      * Renames a user.
 161      *
 162      * @param aOldUserName
 163      *            Current user name.
 164      * @param aUserName
 165      *            New user name.
 166      *
 167      * @throws UserMgtException
 168      *             In case the user is not known or the new user name is already
 169      *             in use by another user.
 170      */
 171     void renameUser(String aOldUserName, String aUserName);
 172
 173     /**
 174      * Renames a group.
 175      *
 176      * @param aGroup
 177      *            Group to rename.
 178      * @param aGroupName
 179      *            New name for the group.
 180      *
 181      * @throws UserMgtException
 182      *             In case the new group name is already used by another group
 183      *             of if the existing group is unknown.
 184      */
 185     void renameGroup(String aOldGroup, String aGroupName);
 186
 187     /**
 188      * Removes the user.
 189      *
 190      * @param aUser
 191      *            User to remove.
 192      *
 193      * @throws UserMgtException
 194      *             In case the user does not exist.
 195      */
 196     void removeUser(String aUser);
 197
 198     /**
 199      * Removes the group.
 200      *
 201      * @param aGroup
 202      *            Group to remove.
 203      *
 204      * @throws UserMgtException
 205      *             In case there are still users that are in the given group.
 206      */
 207     void removeGroup(String aGroup);
 208
 209     /**
 210      * Adds a user to a group.
 211      *
 212      * @param aUser
 213      *            User.
 214      * @param aGroup
 215      *            Group.
 216      *
 217      * @throws UserMgtException
 218      *             In case the user or group or not known or if the user is
 219      *             already part of the group.
 220      */
 221     void addUserToGroup(String aUser, String aGroup);
 222
 223     /**
 224      * Removes a user from a group.
 225      *
 226      * @param aUser
 227      *            User
 228      * @param aGroup
 229      *            Group
 230      *
 231      * @throws UserMgtException
 232      *             In case the user or group are unknown or if the user is not
 233      *             part of the group.
 234      */
 235     void removeUserFromGroup(String aUser, String aGroup);
 236 }