--- /dev/null
+/*
+ * Copyright 2005-2010 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.wamblee.security.authentication;
+
+import static org.wamblee.security.authentication.UserMgtException.Reason.*;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.wamblee.security.authentication.UserMgtException.Reason;
+
+/**
+ * Administration of users and groups.
+ *
+ * @author Erik Brakkee
+ */
+public class UserAdministrationImpl implements UserAdministration {
+ /**
+ * All known users.
+ */
+ private UserSet users;
+
+ /**
+ * All known groups.
+ */
+ private GroupSet groups;
+
+ /**
+ * Validator for user names.
+ */
+ private NameValidator userValidator;
+
+ /**
+ * Validator for group names.
+ */
+ private NameValidator groupValidator;
+
+ /**
+ * Constructs empty user administration.
+ *
+ */
+ public UserAdministrationImpl(UserSet aUsers, GroupSet aGroups,
+ NameValidator aUserValidator, NameValidator aGroupValidator) {
+ users = aUsers;
+ groups = aGroups;
+ userValidator = aUserValidator;
+ groupValidator = aGroupValidator;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.wamblee.usermgt.UserAdministration#createUser(java.lang.String,
+ * java.lang.String)
+ */
+ @Override
+ public void createUser(String aUser, String aPassword) {
+ if (!userValidator.validate(aUser)) {
+ throw new UserMgtException(Reason.INVALID_USERNAME, aUser);
+ }
+
+ users.createUser(aUser, aPassword);
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.wamblee.usermgt.UserAdministration#createGroup(java.lang.String)
+ */
+ @Override
+ public void createGroup(String aName) {
+ if (!groupValidator.validate(aName)) {
+ throw new UserMgtException(Reason.INVALID_GROUPNAME, aName);
+ }
+
+ Group group = new Group(aName);
+
+ if (groups.contains(group)) {
+ throw new UserMgtException(DUPLICATE_GROUP, group);
+ }
+
+ groups.add(group);
+ }
+
+ @Override
+ public boolean checkUser(String aUser) {
+ return users.find(aUser) != null;
+ }
+
+ @Override
+ public boolean checkGroup(String aGroup) {
+ return groups.find(aGroup) != null;
+ }
+
+ @Override
+ public boolean checkPassword(String aUser, String aPassword) {
+ User user = requireUser(aUser, "While checking password");
+ return user.checkPassword(aPassword);
+ }
+
+ private User requireUser(String aUser, String aMsg) {
+ User user = users.find(aUser);
+ if (user == null) {
+ throw new UserMgtException(Reason.UNKNOWN_USER, aMsg);
+ }
+ return user;
+ }
+
+ private Group requireGroup(String aGroup, String aMsg) {
+ Group group = groups.find(aGroup);
+ if (group == null) {
+ throw new UserMgtException(Reason.UNKNOWN_GROUP, aMsg);
+ }
+ return group;
+ }
+
+ @Override
+ public boolean changePassword(String aUser, String aOldPassword,
+ String aNewPassword) {
+ User user = requireUser(aUser, "While checking password");
+ boolean res = user.changePassword(aOldPassword, aNewPassword);
+ users.userModified(user);
+ return res;
+ }
+
+ @Override
+ public void setPassword(String aUser, String aPassword) {
+ User user = requireUser(aUser, "While setting password");
+ user.setPassword(aPassword);
+ users.userModified(user);
+ }
+
+ @Override
+ public boolean isInGroup(String aUser, String aGroup) {
+ User user = requireUser(aUser,
+ "While checking whether user belongs to group");
+ return user.isInGroup(aGroup);
+ }
+
+ @Override
+ public int getUserCount() {
+ return users.size();
+ }
+
+ @Override
+ public int getGroupCount() {
+ return groups.size();
+ }
+
+ @Override
+ public List<String> getUsers() {
+ List<String> res = new ArrayList<String>();
+ for (User user : users.list()) {
+ res.add(user.getName());
+ }
+ return res;
+ }
+
+ @Override
+ public List<String> getUsers(String aGroup) {
+ Group group = requireGroup(aGroup, "While finding users for group");
+ List<String> res = new ArrayList<String>();
+ for (User user : users.list(group)) {
+ res.add(user.getName());
+ }
+ return res;
+ }
+
+ @Override
+ public List<String> getGroups() {
+ List<String> res = new ArrayList<String>();
+ for (Group group : groups.list()) {
+ res.add(group.getName());
+ }
+ return res;
+ }
+
+ @Override
+ public List<String> getGroups(String aUser) {
+ User user = requireUser(aUser, "While getting list of groups");
+ List<String> res = new ArrayList<String>();
+ for (Group g : user.getGroups()) {
+ res.add(g.getName());
+ }
+ return res;
+ }
+
+ @Override
+ public void renameUser(String aOldUsername, String aNewUsername) {
+ User user = requireUser(aOldUsername, "While renaming user");
+
+ if (aOldUsername.equals(aNewUsername)) {
+ return; // nothing to do.
+ }
+
+ if (users.find(aNewUsername) != null) {
+ throw new UserMgtException(DUPLICATE_USER, aNewUsername);
+ }
+
+ if (!userValidator.validate(aNewUsername)) {
+ throw new UserMgtException(Reason.INVALID_USERNAME, aNewUsername);
+ }
+
+ user.setName(aNewUsername);
+ users.userModified(user);
+ }
+
+ @Override
+ public void renameGroup(String aOldGroup, String aNewGroup) {
+ Group group = requireGroup(aOldGroup, "While renaming group");
+
+ if (aOldGroup.equals(aNewGroup)) {
+ return; // OK.
+ }
+
+ if (groups.find(aNewGroup) != null) {
+ throw new UserMgtException(DUPLICATE_GROUP, aNewGroup);
+ }
+
+ if (!groupValidator.validate(aNewGroup)) {
+ throw new UserMgtException(Reason.INVALID_GROUPNAME, aNewGroup);
+ }
+
+ group.setName(aNewGroup);
+ groups.groupModified(group);
+ // Because a group has changed, a cached user could contain reference to an old copy of the
+ // group. Therefore, we clear the cache in this case.
+ users.clearCache();
+ }
+
+ @Override
+ public void removeUser(String aUser) {
+ User user = requireUser(aUser, "While removing user");
+ boolean removed = users.remove(user);
+ if (!removed) {
+ throw new UserMgtException(Reason.UNKNOWN_USER, aUser);
+ }
+ }
+
+ @Override
+ public void removeGroup(String aGroup) {
+ Group group = requireGroup(aGroup, "While removing group");
+
+ if (getUsers(aGroup).size() > 0) {
+ throw new UserMgtException(GROUP_STILL_OCCUPIED, aGroup);
+ }
+
+ boolean removed = groups.remove(group);
+ if (!removed) {
+ throw new UserMgtException(Reason.UNKNOWN_GROUP, aGroup);
+ }
+ }
+
+ @Override
+ public void addUserToGroup(String aUser, String aGroup) {
+ User user = requireUser(aUser, "While adding user to group");
+ Group group = requireGroup(aGroup, "While adding user to group");
+ user.addGroup(group);
+ users.userModified(user);
+ }
+
+ @Override
+ public void removeUserFromGroup(String aUser, String aGroup) {
+ User user = requireUser(aUser, "While removing user from group");
+ Group group = requireGroup(aGroup, "While removing user from group");
+ user.removeGroup(group);
+ users.userModified(user);
+ }
+}
git://wamblee.org / utils / blobdiff