cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/User.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.model.common;
  11
  12 import java.util.Collection;
  13 import java.util.HashSet;
  14 import java.util.Set;
  15
  16 import javax.persistence.Entity;
  17 import javax.persistence.FetchType;
  18 import javax.persistence.ManyToMany;
  19 import javax.persistence.OneToOne;
  20 import javax.persistence.Table;
  21 import javax.persistence.Transient;
  22 import javax.xml.bind.annotation.XmlAccessType;
  23 import javax.xml.bind.annotation.XmlAccessorType;
  24 import javax.xml.bind.annotation.XmlElement;
  25 import javax.xml.bind.annotation.XmlElementWrapper;
  26 import javax.xml.bind.annotation.XmlIDREF;
  27 import javax.xml.bind.annotation.XmlRootElement;
  28 import javax.xml.bind.annotation.XmlSchemaType;
  29 import javax.xml.bind.annotation.XmlTransient;
  30 import javax.xml.bind.annotation.XmlType;
  31
  32 import org.apache.log4j.Logger;
  33 import org.hibernate.annotations.Cascade;
  34 import org.hibernate.annotations.CascadeType;
  35 import org.hibernate.annotations.NaturalId;
  36 import org.hibernate.envers.Audited;
  37 import org.hibernate.envers.NotAudited;
  38 import org.hibernate.search.annotations.Analyze;
  39 import org.hibernate.search.annotations.Field;
  40 import org.hibernate.search.annotations.Indexed;
  41 import org.hibernate.search.annotations.IndexedEmbedded;
  42 import org.springframework.security.core.GrantedAuthority;
  43 import org.springframework.security.core.userdetails.UserDetails;
  44
  45 import eu.etaxonomy.cdm.model.agent.Person;
  46
  47 @XmlAccessorType(XmlAccessType.FIELD)
  48 @XmlType(name = "User", propOrder = {
  49     "username",
  50     "password",
  51     "emailAddress",
  52     "grantedAuthorities",
  53     "groups",
  54     "enabled",
  55     "accountNonExpired",
  56     "credentialsNonExpired",
  57     "accountNonLocked",
  58     "person"
  59 })
  60 @XmlRootElement(name = "User")
  61 @Entity
  62 @Indexed(index = "eu.etaxonomy.cdm.model.common.User")
  63 @Audited
  64 @Table(name = "UserAccount")
  65 public class User extends CdmBase implements UserDetails {
  66     private static final long serialVersionUID = 6582191171369439163L;
  67     private static final Logger logger = Logger.getLogger(User.class);
  68
  69     protected User(){
  70         super();
  71     }
  72
  73     public static User NewInstance(String username, String pwd){
  74         User user = new User();
  75         user.setUsername(username);
  76         user.setPassword(pwd);
  77
  78         user.setAccountNonExpired(true);
  79         user.setAccountNonLocked(true);
  80         user.setCredentialsNonExpired(true);
  81         user.setEnabled(true);
  82
  83         return user;
  84     }
  85
  86     public static User NewInstance(String personTitle, String username, String pwd){
  87         User user = new User();
  88         user.setUsername(username);
  89         user.setPassword(pwd);
  90
  91         user.setAccountNonExpired(true);
  92         user.setAccountNonLocked(true);
  93         user.setCredentialsNonExpired(true);
  94         user.setEnabled(true);
  95         Person userPerson = Person.NewTitledInstance(personTitle);
  96         user.setPerson(userPerson);
  97
  98         return user;
  99     }
 100
 101     @XmlElement(name = "Username")
 102     @NaturalId
 103     @Field(analyze = Analyze.NO)
 104     protected String username;
 105
 106     /**
 107      * a salted, MD5 encoded hash of the plaintext password
 108      */
 109     @XmlElement(name = "Password")
 110     @NotAudited
 111     protected String password;
 112
 113     @XmlElement(name = "EmailAddress")
 114     protected String emailAddress;
 115
 116     @XmlElementWrapper(name = "GrantedAuthorities")
 117     @XmlElement(name = "GrantedAuthority", type = GrantedAuthorityImpl.class)
 118     @XmlIDREF
 119     @XmlSchemaType(name = "IDREF")
 120     @ManyToMany(fetch = FetchType.LAZY, targetEntity = GrantedAuthorityImpl.class)
 121     @Cascade(CascadeType.SAVE_UPDATE)
 122     @NotAudited
 123     protected Set<GrantedAuthority> grantedAuthorities = new HashSet<GrantedAuthority>();  //authorities of this user only
 124
 125     @XmlElementWrapper(name = "Groups")
 126     @XmlElement(name = "Group")
 127     @XmlIDREF
 128     @XmlSchemaType(name = "IDREF")
 129     @ManyToMany(fetch = FetchType.LAZY)
 130     @IndexedEmbedded(depth = 1)
 131     @NotAudited
 132     protected Set<Group> groups = new HashSet<Group>();
 133
 134     @XmlElement(name = "Enabled")
 135     protected boolean enabled;
 136
 137     @XmlElement(name = "AccountNonExpired")
 138     protected boolean accountNonExpired;
 139
 140     @XmlElement(name = "CredentialsNonExpired")
 141     protected boolean credentialsNonExpired;
 142
 143     @XmlElement(name = "AccountNonLocked")
 144     protected boolean accountNonLocked;
 145
 146     @XmlElement(name = "Person")
 147     @XmlIDREF
 148     @XmlSchemaType(name = "IDREF")
 149     @OneToOne(fetch = FetchType.LAZY)
 150     @Cascade({CascadeType.SAVE_UPDATE})
 151     @IndexedEmbedded(depth = 1)
 152     protected Person person;
 153
 154     @XmlTransient
 155     @Transient
 156     private Set<GrantedAuthority> authorities;  //authorities of this user and of all groups the user belongs to
 157
 158     private void initAuthorities() {
 159         authorities = new HashSet<GrantedAuthority>();
 160         authorities.addAll(grantedAuthorities);
 161         for(Group group : groups) {
 162             authorities.addAll(group.getGrantedAuthorities());
 163         }
 164     }
 165
 166     /**
 167      * {@inheritDoc}
 168      *
 169      * @return returns a {@code Set<GrantedAuthority>} as Collection
 170      */
 171     @Override
 172     @Transient
 173     public Collection<GrantedAuthority> getAuthorities() {
 174         if(authorities == null || authorities.size() == 0) {
 175             initAuthorities();
 176         }
 177         return authorities;
 178     }
 179
 180     @Override
 181     public String getPassword() {
 182         return password;
 183     }
 184
 185     @Override
 186     public String getUsername() {
 187         return username;
 188     }
 189
 190     @Override
 191     public boolean isAccountNonExpired() {
 192         return accountNonExpired;
 193     }
 194
 195     @Override
 196     public boolean isAccountNonLocked() {
 197         return accountNonLocked;
 198     }
 199
 200     @Override
 201     public boolean isCredentialsNonExpired() {
 202         return credentialsNonExpired;
 203     }
 204
 205     @Override
 206     public boolean isEnabled() {
 207         return enabled;
 208     }
 209
 210     public String getEmailAddress() {
 211         return emailAddress;
 212     }
 213
 214     public void setEmailAddress(String emailAddress) {
 215         this.emailAddress = emailAddress;
 216     }
 217
 218     public Set<GrantedAuthority> getGrantedAuthorities() {
 219         return grantedAuthorities;
 220     }
 221
 222     public void setGrantedAuthorities(Set<GrantedAuthority> grantedAuthorities) {
 223         this.grantedAuthorities = grantedAuthorities;
 224         initAuthorities();
 225     }
 226
 227     public void setUsername(String username) {
 228         this.username = username;
 229     }
 230
 231     public void setPassword(String password) {
 232         this.password = password;
 233     }
 234
 235     public void setEnabled(boolean enabled) {
 236         this.enabled = enabled;
 237     }
 238
 239     public void setAccountNonExpired(boolean accountNonExpired) {
 240         this.accountNonExpired = accountNonExpired;
 241     }
 242
 243     public void setCredentialsNonExpired(boolean credentialsNonExpired) {
 244         this.credentialsNonExpired = credentialsNonExpired;
 245     }
 246
 247     public void setAccountNonLocked(boolean accountNonLocked) {
 248         this.accountNonLocked = accountNonLocked;
 249     }
 250
 251     protected void setGroups(Set<Group> groups) {
 252         this.groups = groups;
 253         initAuthorities();
 254     }
 255
 256     public Set<Group> getGroups() {
 257         return groups;
 258     }
 259
 260
 261     public Person getPerson() {
 262         return person;
 263     }
 264
 265     public void setPerson(Person person) {
 266         this.person = person;
 267     }
 268
 269 //*********************** CLONE ********************************************************/
 270
 271     /**
 272      * Clones <i>this</i> User. This is a shortcut that enables to create
 273      * a new instance that differs only slightly from <i>this</i> User.
 274      * The corresponding person is cloned.
 275      *
 276      * @see eu.etaxonomy.cdm.model.common.CdmBase#clone()
 277      * @see java.lang.Object#clone()
 278      */
 279     @Override
 280     public Object clone() {
 281         try{
 282             User result = (User)super.clone();
 283             result.setPerson((Person)this.person.clone());
 284             return result;
 285         } catch (CloneNotSupportedException e){
 286             logger.warn("Object does not implement cloneable");
 287             e.printStackTrace();
 288             return null;
 289         }
 290
 291
 292     }
 293 }