wamblee.org Git - utils/blob - security/usermgt/src/main/java/org/wamblee/security/authentication/User.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.io.Serializable;
  19 import java.util.Set;
  20 import java.util.TreeSet;
  21
  22 import javax.persistence.CascadeType;
  23 import javax.persistence.Entity;
  24 import javax.persistence.FetchType;
  25 import javax.persistence.GeneratedValue;
  26 import javax.persistence.GenerationType;
  27 import javax.persistence.Id;
  28 import javax.persistence.JoinColumn;
  29 import javax.persistence.JoinTable;
  30 import javax.persistence.ManyToMany;
  31 import javax.persistence.NamedQueries;
  32 import javax.persistence.NamedQuery;
  33 import javax.persistence.Table;
  34 import javax.persistence.Transient;
  35 import javax.persistence.Version;
  36
  37 import org.wamblee.security.authentication.UserMgtException.Reason;
  38
  39 /**
  40  * Represents a user. The methods for managing the groups of the user have
  41  * package scope. Managing the groups of the user should be done through the
  42  * {@link org.wamblee.security.authentication.UserAdministration} interface.
  43  */
  44 @Entity
  45 @Table(name = "SEC_USER")
  46 @NamedQueries( {
  47     @NamedQuery(name = User.QUERY_FIND_BY_NAME, query = "select u from User u where u.name = :" +
  48         User.NAME_PARAM),
  49     @NamedQuery(name = User.QUERY_FIND_BY_GROUP_NAME, query = "select user from User user join user.groups grp where grp.name = :name"),
  50     @NamedQuery(name = User.QUERY_COUNT_USERS, query = "select count(u) from User u"),
  51     @NamedQuery(name = User.QUERY_ALL_USERS, query = "select u from User u") })
  52 public class User implements Serializable, Comparable {
  53
  54     public static final String QUERY_FIND_BY_NAME = "User.findByName";
  55     public static final String QUERY_FIND_BY_GROUP_NAME = "User.findByGroupName";
  56     public static final String QUERY_COUNT_USERS = "User.count";
  57     public static final String QUERY_ALL_USERS = "User.all";
  58     public static final String NAME_PARAM = "name";
  59
  60     @Id
  61     @GeneratedValue(strategy = GenerationType.AUTO)
  62     private Long id;
  63
  64     @Version
  65     private int version;
  66
  67     /**
  68      * User name.
  69      */
  70     private String name;
  71
  72     /**
  73      * Password.
  74      */
  75     private String password;
  76
  77     /**
  78      * Groups the user belongs to.
  79      */
  80     @ManyToMany(cascade = CascadeType.MERGE, fetch = FetchType.EAGER)
  81     @JoinTable(name = "SEC_USER_GROUP", joinColumns = { @JoinColumn(name = "USER_ID") }, inverseJoinColumns = { @JoinColumn(name = "GROUP_ID") })
  82     private Set<Group> groups;
  83
  84     /**
  85      * Password validator.
  86      */
  87     @Transient
  88     private NameValidator passwordValidator;
  89
  90     /**
  91      * Password encoder.
  92      */
  93     @Transient
  94     private MessageDigester passwordEncoder;
  95
  96     /**
  97      * Constructs the user.
  98      *
  99      * @param aName
 100      *            User name.
 101      * @param aPassword
 102      *            Password.
 103      */
 104     User(String aName, String aPassword, NameValidator aPasswordValidator,
 105         MessageDigester aPasswordEncoder) {
 106         super();
 107         name = aName;
 108         aPasswordValidator.validate(aPassword);
 109         password = aPasswordEncoder.hash(aPassword);
 110         groups = new TreeSet<Group>();
 111         passwordValidator = aPasswordValidator;
 112         passwordEncoder = aPasswordEncoder;
 113     }
 114
 115     /**
 116      * Creates a new User object.
 117      *
 118      */
 119     public User(User aUser) {
 120         id = aUser.id;
 121         version = aUser.version;
 122         name = aUser.name;
 123         password = aUser.password;
 124         groups = new TreeSet<Group>();
 125
 126         for (Group group : aUser.groups) {
 127             groups.add(new Group(group));
 128         }
 129
 130         passwordValidator = aUser.passwordValidator;
 131         passwordEncoder = aUser.passwordEncoder;
 132     }
 133
 134     /**
 135      * Creates a new User object.
 136      */
 137     User() {
 138         super();
 139         name = null;
 140         password = null;
 141         groups = null;
 142         passwordValidator = null;
 143         passwordEncoder = null;
 144     }
 145
 146     /**
 147      * Sets the password validator.
 148      *
 149      * @param aPasswordValidator
 150      *            Validator.
 151      */
 152     public void setPasswordValidator(NameValidator aPasswordValidator) {
 153         passwordValidator = aPasswordValidator;
 154     }
 155
 156     /**
 157      * Sets the password encoder.
 158      *
 159      * @param aPasswordEncoder
 160      *            Encoder.
 161      */
 162     public void setPasswordEncoder(MessageDigester aPasswordEncoder) {
 163         passwordEncoder = aPasswordEncoder;
 164     }
 165
 166     /**
 167      *
 168      * @return Returns the password.
 169      */
 170     String getPassword() {
 171         return password;
 172     }
 173
 174     /**
 175      * Checks the password.
 176      *
 177      * @param aPassword
 178      *            Password to check.
 179      *
 180      * @return True iff the password is correct.
 181      */
 182     public boolean checkPassword(String aPassword) {
 183         String encoded = passwordEncoder.hash(aPassword);
 184
 185         return password.equals(encoded);
 186     }
 187
 188     /**
 189      * Changes the password.
 190      *
 191      * @param aOldPassword
 192      *            Old password.
 193      * @param aNewPassword
 194      *            New password.
 195      *
 196      * @return True iff the password was changed successfully.
 197      */
 198     public boolean changePassword(String aOldPassword, String aNewPassword) {
 199         if (!checkPassword(aOldPassword)) {
 200             return false;
 201         }
 202         passwordValidator.validate(aNewPassword);
 203         setPassword(aNewPassword);
 204         return true;
 205     }
 206
 207     /**
 208      *
 209      * @param aPassword
 210      *            The password to set.
 211      *
 212      */
 213     public void setPassword(String aPassword) {
 214         passwordValidator.validate(aPassword);
 215         password = passwordEncoder.hash(aPassword);
 216     }
 217
 218     /**
 219      * For OR mapping.
 220      *
 221      * @return Password.
 222      */
 223     protected String getPasswordString() {
 224         return password;
 225     }
 226
 227     /**
 228      * For OR mapping.
 229      *
 230      * @param aPassword
 231      *            Password.
 232      */
 233     protected void setPasswordString(String aPassword) {
 234         password = aPassword;
 235     }
 236
 237     /**
 238      *
 239      * @return Returns the _user.
 240      */
 241     public String getName() {
 242         return name;
 243     }
 244
 245     /**
 246      *
 247      * @param aName
 248      *            The username to set.
 249      */
 250     void setName(String aName) {
 251         name = aName;
 252     }
 253
 254     /**
 255      * Gets the groups the user belongs to.
 256      *
 257      * @return Groups.
 258      */
 259     public Set<Group> getGroups() {
 260         Set<Group> result = new TreeSet<Group>();
 261         result.addAll(groups);
 262
 263         return result;
 264     }
 265
 266     /**
 267      * Checks whether the user belongs to the given group.
 268      *
 269      * @param aGroup
 270      *            Group.
 271      *
 272      * @return True if the user belongs to the group.
 273      */
 274     public boolean isInGroup(Group aGroup) {
 275         return groups.contains(aGroup);
 276     }
 277
 278     /**
 279      * Checks whether the user belongs to the given group.
 280      *
 281      * @param aGroup
 282      *            Group.
 283      *
 284      * @return True if the user belongs to the group.
 285      */
 286     public boolean isInGroup(String aGroup) {
 287         return groups.contains(new Group(aGroup));
 288     }
 289
 290     /**
 291      * Gets the group set. For OR mapping.
 292      *
 293      * @return set of groups.
 294      */
 295     Set<Group> getGroupSet() {
 296         return groups;
 297     }
 298
 299     /**
 300      * Sets the groups the user belongs to, for OR mapping.
 301      *
 302      * @param aGroups
 303      *            Groups.
 304      */
 305     void setGroupSet(Set<Group> aGroups) {
 306         groups = aGroups;
 307     }
 308
 309     /**
 310      * Adds the user to a group.
 311      *
 312      * @param aGroup
 313      *            Group to add the user to.
 314      *
 315      * @throws UserMgtException
 316      *             In case the user already belongs to the group.
 317      */
 318     void addGroup(Group aGroup) throws UserMgtException {
 319         if (groups.contains(aGroup)) {
 320             throw new UserMgtException(Reason.USER_ALREADY_IN_GROUP, aGroup);
 321         }
 322
 323         groups.add(aGroup);
 324     }
 325
 326     /**
 327      * Removes the user from a group.
 328      *
 329      * @param aGroup
 330      *            Group.
 331      *
 332      * @throws UserMgtException
 333      *             In case the user does not belong to the group.
 334      */
 335     void removeGroup(Group aGroup) {
 336         if (!groups.contains(aGroup)) {
 337             throw new UserMgtException(Reason.USER_NOT_IN_GROUP, this, aGroup);
 338         }
 339
 340         groups.remove(aGroup);
 341     }
 342
 343     /*
 344      * (non-Javadoc)
 345      *
 346      * @see java.lang.Object#equals(java.lang.Object)
 347      */
 348     @Override
 349     public boolean equals(Object aUser) {
 350         if (aUser == null) {
 351             return false;
 352         }
 353         if (!(aUser instanceof User)) {
 354             return false;
 355         }
 356
 357         User user = (User) aUser;
 358
 359         return name.equals(user.name);
 360     }
 361
 362     /*
 363      * (non-Javadoc)
 364      *
 365      * @see java.lang.Object#hashCode()
 366      */
 367     @Override
 368     public int hashCode() {
 369         return name.hashCode();
 370     }
 371
 372     /*
 373      * (non-Javadoc)
 374      *
 375      * @see java.lang.Object#toString()
 376      */
 377     @Override
 378     public String toString() {
 379         String result = "User(name=" + name + ", password=" + password;
 380
 381         for (Group group : groups) {
 382             result += (", group=" + group);
 383         }
 384
 385         return result + ")";
 386     }
 387
 388     /*
 389      * (non-Javadoc)
 390      *
 391      * @see java.lang.Comparable#compareTo(T)
 392      */
 393     public int compareTo(Object aUser) {
 394         return name.compareTo(((User) aUser).name);
 395     }
 396
 397     public Long getPrimaryKey() {
 398         return id;
 399     }
 400 }