X-Git-Url: http://wamblee.org/gitweb/?a=blobdiff_plain;f=security%2Fsrc%2Fmain%2Fjava%2Forg%2Fwamblee%2Fusermgt%2FUser.java;h=53e95537943ef576934d7a3ebb81d88f9ebd8a7e;hb=ddd261f331280640c5b53c7128230b629ebcd268;hp=0a69cef9b27cd21cf3b72aa3d17f2ed056b09168;hpb=92e23e5ecf9614f2ab770a8cdedc0b21ddf1e127;p=utils diff --git a/security/src/main/java/org/wamblee/usermgt/User.java b/security/src/main/java/org/wamblee/usermgt/User.java index 0a69cef9..53e95537 100644 --- a/security/src/main/java/org/wamblee/usermgt/User.java +++ b/security/src/main/java/org/wamblee/usermgt/User.java @@ -1,174 +1,204 @@ /* * Copyright 2005 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.usermgt; +import org.wamblee.persistence.AbstractPersistent; + +import org.wamblee.security.encryption.MessageDigester; + +import org.wamblee.usermgt.UserMgtException.Reason; + import java.io.Serializable; + import java.util.Set; import java.util.TreeSet; -import org.wamblee.persistence.AbstractPersistent; -import org.wamblee.security.encryption.MessageDigester; -import org.wamblee.usermgt.UserMgtException.Reason; /** - * Represents a user. - * The methods for managing the groups of the user have package scope. - * Managing the groups of the user should be done through the - * {@link org.wamblee.usermgt.UserAdministration} interface. + * Represents a user. The methods for managing the groups of the user have + * package scope. Managing the groups of the user should be done through the + * {@link org.wamblee.usermgt.UserAdministration} interface. */ -public class User extends AbstractPersistent implements Serializable, Comparable { - +public class User extends AbstractPersistent implements Serializable, + Comparable { /** - * User name. + * User name. */ private String name; /** - * Password. + * Password. */ private String password; /** - * Groups the user belongs to. + * Groups the user belongs to. */ private Set groups; - + /** - * Password validator. + * Password validator. */ - private NameValidator passwordValidator; + private NameValidator passwordValidator; /** - * Password encoder. + * Password encoder. */ private MessageDigester passwordEncoder; - - /** + +/** * Constructs the user. * @param aName User name. * @param aPassword Password. * @param aGroup Group the user belongs to. */ - User(String aName, String aPassword, Group aGroup, NameValidator aPasswordValidator, - MessageDigester aPasswordEncoder) throws UserMgtException { - super(); + User(String aName, String aPassword, Group aGroup, + NameValidator aPasswordValidator, MessageDigester aPasswordEncoder) + throws UserMgtException { + super(); name = aName; aPasswordValidator.validate(aPassword); - password = aPasswordEncoder.hash(aPassword); - groups = new TreeSet(); + password = aPasswordEncoder.hash(aPassword); + groups = new TreeSet(); groups.add(aGroup); - passwordValidator = aPasswordValidator; - passwordEncoder = aPasswordEncoder; + passwordValidator = aPasswordValidator; + passwordEncoder = aPasswordEncoder; } - - public User(User aUser) { - super(aUser); - name = aUser.name; - password = aUser.password; - groups = new TreeSet(); - for (Group group: aUser.groups) { - groups.add(new Group(group)); + +/** + * Creates a new User object. + * + * @param aUser DOCUMENT ME! + */ + public User(User aUser) { + super(aUser); + name = aUser.name; + password = aUser.password; + groups = new TreeSet(); + + for (Group group : aUser.groups) { + groups.add(new Group(group)); } - passwordValidator = aUser.passwordValidator; - passwordEncoder = aUser.passwordEncoder; + + passwordValidator = aUser.passwordValidator; + passwordEncoder = aUser.passwordEncoder; } - - User() { - super(); - name = null; - password = null; - groups = null; - passwordValidator = null; - passwordEncoder = null; + +/** + * Creates a new User object. + */ + User() { + super(); + name = null; + password = null; + groups = null; + passwordValidator = null; + passwordEncoder = null; } - + /** - * Sets the password validator. - * @param aPasswordValidator Validator. + * Sets the password validator. + * + * @param aPasswordValidator Validator. */ - public void setPasswordValidator(NameValidator aPasswordValidator) { + public void setPasswordValidator(NameValidator aPasswordValidator) { passwordValidator = aPasswordValidator; } - + /** - * Sets the password encoder. - * @param aPasswordEncoder Encoder. + * Sets the password encoder. + * + * @param aPasswordEncoder Encoder. */ - public void setPasswordEncoder(MessageDigester aPasswordEncoder) { - passwordEncoder = aPasswordEncoder; + public void setPasswordEncoder(MessageDigester aPasswordEncoder) { + passwordEncoder = aPasswordEncoder; } /** + * DOCUMENT ME! + * * @return Returns the password. */ String getPassword() { return password; } - + /** - * Checks the password. - * @param aPassword Password to check. - * @throws UserMgtException In case the password is incorrect. + * Checks the password. + * + * @param aPassword Password to check. + * + * @throws UserMgtException In case the password is incorrect. */ public void checkPassword(String aPassword) throws UserMgtException { String encoded = passwordEncoder.hash(aPassword); - if ( !password.equals(encoded) ) { + + if (!password.equals(encoded)) { throw new UserMgtException(Reason.INVALID_PASSWORD, this); } } - + /** - * Changes the password. - * @param aOldPassword Old password. - * @param aNewPassword New password. - * @throws UserMgtException In case the old password is incorrect. + * Changes the password. + * + * @param aOldPassword Old password. + * @param aNewPassword New password. + * + * @throws UserMgtException In case the old password is incorrect. */ - public void changePassword(String aOldPassword, String aNewPassword) throws UserMgtException { + public void changePassword(String aOldPassword, String aNewPassword) + throws UserMgtException { checkPassword(aOldPassword); passwordValidator.validate(aNewPassword); setPassword(aNewPassword); } /** - * @param aPassword - * The password to set. + * DOCUMENT ME! + * + * @param aPassword The password to set. + * + * @throws UserMgtException DOCUMENT ME! */ public void setPassword(String aPassword) throws UserMgtException { passwordValidator.validate(aPassword); password = passwordEncoder.hash(aPassword); } - + /** - * For OR mapping. - * @return Password. + * For OR mapping. + * + * @return Password. */ - protected String getPasswordString() { + protected String getPasswordString() { return password; } - + /** - * For OR mapping. - * @param aPassword Password. + * For OR mapping. + * + * @param aPassword Password. */ - protected void setPasswordString(String aPassword) { - password = aPassword; + protected void setPasswordString(String aPassword) { + password = aPassword; } /** + * DOCUMENT ME! + * * @return Returns the _user. */ public String getName() { @@ -176,51 +206,69 @@ public class User extends AbstractPersistent implements Serializable, Comparable } /** - * @param aName - * The username to set. + * DOCUMENT ME! + * + * @param aName The username to set. */ void setName(String aName) { name = aName; } /** - * Gets the groups the user belongs to. + * Gets the groups the user belongs to. + * * @return Groups. */ public Set getGroups() { - Set result = new TreeSet(); + Set result = new TreeSet(); result.addAll(groups); - return result; + + return result; } - + /** - * Checks whether the user belongs to the given group. - * @param aGroup Group. + * Checks whether the user belongs to the given group. + * + * @param aGroup Group. + * * @return True if the user belongs to the group. */ public boolean isInGroup(Group aGroup) { return groups.contains(aGroup); } - + /** - * Checks whether the user belongs to the given group. - * @param aGroup Group. + * Checks whether the user belongs to the given group. + * + * @param aGroup Group. + * * @return True if the user belongs to the group. */ public boolean isInGroup(String aGroup) { return groups.contains(new Group(aGroup)); } - + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ +/** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ +/** * Gets the group set. For OR mapping. * @return set of groups. */ - Set getGroupSet() { + Set getGroupSet() { return groups; } /** - * Sets the groups the user belongs to, for OR mapping. + * Sets the groups the user belongs to, for OR mapping. + * * @param aGroups Groups. */ void setGroupSet(Set aGroups) { @@ -228,68 +276,104 @@ public class User extends AbstractPersistent implements Serializable, Comparable } /** - * Adds the user to a group. + * Adds the user to a group. + * * @param aGroup Group to add the user to. - * @throws UserMgtException In case the user already belongs to the group. + * + * @throws UserMgtException In case the user already belongs to the group. */ void addGroup(Group aGroup) throws UserMgtException { if (groups.contains(aGroup)) { throw new UserMgtException(Reason.USER_ALREADY_IN_GROUP, aGroup); } + groups.add(aGroup); } /** - * Removes the user from a group. - * @param aGroup Group. + * Removes the user from a group. + * + * @param aGroup Group. + * * @throws UserMgtException In case the user does not belong to the group. */ void removeGroup(Group aGroup) throws UserMgtException { if (!groups.contains(aGroup)) { throw new UserMgtException(Reason.USER_NOT_IN_GROUP, this, aGroup); } - if ( groups.size() == 1 ) { - throw new UserMgtException(Reason.USER_MUST_BE_IN_A_GROUP, this, aGroup); + + if (groups.size() == 1) { + throw new UserMgtException(Reason.USER_MUST_BE_IN_A_GROUP, this, + aGroup); } + groups.remove(aGroup); } - + /* (non-Javadoc) * @see java.lang.Object#equals(java.lang.Object) */ + /** + * DOCUMENT ME! + * + * @param aUser DOCUMENT ME! + * + * @return DOCUMENT ME! + */ @Override public boolean equals(Object aUser) { - if ( !(aUser instanceof User)) { - return false; + if (!(aUser instanceof User)) { + return false; } - User user = (User)aUser; + + User user = (User) aUser; + return name.equals(user.name); } - + /* (non-Javadoc) * @see java.lang.Object#hashCode() */ + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ @Override public int hashCode() { - return name.hashCode(); + return name.hashCode(); } - + /* (non-Javadoc) * @see java.lang.Object#toString() */ + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + */ @Override public String toString() { String result = "User(name=" + name + ", password=" + password; - for (Group group: groups) { - result += ", group=" + group; + + for (Group group : groups) { + result += (", group=" + group); } - return result + ")"; + + return result + ")"; } - + /* (non-Javadoc) * @see java.lang.Comparable#compareTo(T) */ + /** + * DOCUMENT ME! + * + * @param aUser DOCUMENT ME! + * + * @return DOCUMENT ME! + */ public int compareTo(Object aUser) { - return name.compareTo(((User)aUser).name); + return name.compareTo(((User) aUser).name); } }