wamblee.org Git - utils/blob - security/src/main/java/org/wamblee/usermgt/hibernate/HibernateUserSet.java

   1 /*
   2  * Copyright 2005 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.usermgt.hibernate;
  17
  18 import org.hibernate.SessionFactory;
  19
  20 import org.springframework.orm.hibernate3.HibernateTemplate;
  21
  22 import org.wamblee.cache.Cache;
  23
  24 import org.wamblee.persistence.hibernate.HibernateSupport;
  25
  26 import org.wamblee.security.encryption.MessageDigester;
  27
  28 import org.wamblee.usermgt.AbstractUserSet;
  29 import org.wamblee.usermgt.Group;
  30 import org.wamblee.usermgt.NameValidator;
  31 import org.wamblee.usermgt.User;
  32
  33 import java.util.List;
  34 import java.util.Set;
  35 import java.util.TreeSet;
  36
  37
  38 /**
  39  * User set backed by the database.
  40  *
  41  * @author Erik Brakkee
  42  */
  43 public class HibernateUserSet extends AbstractUserSet {
  44     /**
  45      * DOCUMENT ME!
  46      */
  47     private static final String QUERY_FIND_BY_NAME = "findUserByName";
  48
  49     /**
  50      * DOCUMENT ME!
  51      */
  52     private static final String QUERY_FIND_BY_GROUP_NAME = "findUserByGroupName";
  53
  54     /**
  55      * DOCUMENT ME!
  56      */
  57     private static final String PARAM_NAME = "name";
  58
  59     /**
  60      * DOCUMENT ME!
  61      */
  62     private static final String QUERY_COUNT_USERS = "countUsers";
  63
  64     /**
  65      * Cache of users. Every user in the cache has its password
  66      * validator and encoder set.
  67      */
  68     private Cache<String, User> cache;
  69
  70     /**
  71      * Spring hibernate support.
  72      */
  73     private HibernateSupport hibernateSupport;
  74
  75 /**
  76      * Constructs a user set backed by the database.
  77      * @param aCache User cache to use.
  78      */
  79     public HibernateUserSet(Cache<String, User> aCache,
  80         NameValidator aPasswordValidator, MessageDigester aPasswordEncoder) {
  81         super(aPasswordValidator, aPasswordEncoder);
  82         cache                = aCache;
  83         hibernateSupport     = new HibernateSupport();
  84     }
  85
  86     /**
  87      * Sets the session factory.
  88      *
  89      * @param aFactory Session factory.
  90      */
  91     public void setSessionFactory(SessionFactory aFactory) {
  92         hibernateSupport.setSessionFactory(aFactory);
  93     }
  94
  95     /**
  96      * Gets the hibernate template.
  97      *
  98      * @return Hibernate template.
  99      */
 100     private HibernateTemplate getHibernateTemplate() {
 101         return hibernateSupport.getHibernateTemplate();
 102     }
 103
 104     /*
 105      * (non-Javadoc)
 106      *
 107      * @see org.wamblee.usermgt.UserSet#userModified(org.wamblee.usermgt.User)
 108      */
 109     /**
 110      * DOCUMENT ME!
 111      *
 112      * @param aUser DOCUMENT ME!
 113      */
 114     public void userModified(User aUser) {
 115         assert aUser.getPrimaryKey() != null;
 116         hibernateSupport.merge(aUser);
 117         cache.remove(aUser.getName());
 118         setPasswordInfo(aUser);
 119         cache.put(aUser.getName(), new User(aUser));
 120     }
 121
 122     /*
 123      * (non-Javadoc)
 124      *
 125      * @see org.wamblee.usermgt.UserSet#find(java.lang.String)
 126      */
 127     /**
 128      * DOCUMENT ME!
 129      *
 130      * @param aName DOCUMENT ME!
 131      *
 132      * @return DOCUMENT ME!
 133      *
 134      * @throws RuntimeException DOCUMENT ME!
 135      */
 136     public User find(String aName) {
 137         User user = cache.get(aName);
 138
 139         if (user != null) {
 140             return user;
 141         }
 142
 143         List result = getHibernateTemplate()
 144             .findByNamedQueryAndNamedParam(QUERY_FIND_BY_NAME, PARAM_NAME, aName);
 145
 146         if (result.size() > 1) {
 147             throw new RuntimeException(
 148                 "Implementation problem, more than one user with the same name!");
 149         }
 150
 151         if (result.size() == 0) {
 152             return null;
 153         }
 154
 155         user = (User) result.get(0);
 156         setPasswordInfo(user);
 157         cache.put(aName, user);
 158
 159         return new User(user);
 160     }
 161
 162     /*
 163      * (non-Javadoc)
 164      *
 165      * @see org.wamblee.usermgt.UserSet#contains(org.wamblee.usermgt.User)
 166      */
 167     /**
 168      * DOCUMENT ME!
 169      *
 170      * @param aUser DOCUMENT ME!
 171      *
 172      * @return DOCUMENT ME!
 173      */
 174     public boolean contains(User aUser) {
 175         return find(aUser.getName()) != null;
 176     }
 177
 178     /*
 179      * (non-Javadoc)
 180      *
 181      * @see org.wamblee.usermgt.UserSet#add(org.wamblee.usermgt.User)
 182      */
 183     /**
 184      * DOCUMENT ME!
 185      *
 186      * @param aUser DOCUMENT ME!
 187      *
 188      * @return DOCUMENT ME!
 189      */
 190     public boolean add(User aUser) {
 191         assert aUser.getPrimaryKey() == null;
 192
 193         if (contains(aUser)) {
 194             return false;
 195         }
 196
 197         getHibernateTemplate().saveOrUpdate(aUser);
 198         setPasswordInfo(aUser);
 199         cache.put(aUser.getName(), aUser);
 200
 201         return true;
 202     }
 203
 204     /*
 205      * (non-Javadoc)
 206      *
 207      * @see org.wamblee.usermgt.UserSet#remove(org.wamblee.usermgt.User)
 208      */
 209     /**
 210      * DOCUMENT ME!
 211      *
 212      * @param aUser DOCUMENT ME!
 213      *
 214      * @return DOCUMENT ME!
 215      */
 216     public boolean remove(User aUser) {
 217         assert aUser.getPrimaryKey() != null;
 218
 219         if (!contains(aUser)) {
 220             return false;
 221         }
 222
 223         User user = (User) getHibernateTemplate().merge(aUser);
 224         getHibernateTemplate().delete(user);
 225         aUser.setPersistedVersion(-1);
 226         aUser.setPrimaryKey(null);
 227         cache.remove(aUser.getName());
 228
 229         return true;
 230     }
 231
 232     /*
 233      * (non-Javadoc)
 234      *
 235      * @see org.wamblee.usermgt.UserSet#list()
 236      */
 237     /**
 238      * DOCUMENT ME!
 239      *
 240      * @return DOCUMENT ME!
 241      */
 242     public Set<User> list() {
 243         Set<User>  users = new TreeSet<User>();
 244         List<User> list  = getHibernateTemplate().loadAll(User.class);
 245
 246         for (User user : list) {
 247             setPasswordInfo(user);
 248             users.add(new User(user));
 249         }
 250
 251         return users;
 252     }
 253
 254     /*
 255      * (non-Javadoc)
 256      *
 257      * @see org.wamblee.usermgt.UserSet#list(org.wamblee.usermgt.Group)
 258      */
 259     /**
 260      * DOCUMENT ME!
 261      *
 262      * @param aGroup DOCUMENT ME!
 263      *
 264      * @return DOCUMENT ME!
 265      */
 266     public Set<User> list(Group aGroup) {
 267         Set<User>  users = new TreeSet<User>();
 268         List<User> list  = getHibernateTemplate()
 269             .findByNamedQueryAndNamedParam(QUERY_FIND_BY_GROUP_NAME,
 270                 PARAM_NAME, aGroup.getName());
 271
 272         for (User user : list) {
 273             setPasswordInfo(user);
 274             users.add(new User(user));
 275         }
 276
 277         return users;
 278     }
 279
 280     /* (non-Javadoc)
 281      * @see org.wamblee.usermgt.UserSet#size()
 282      */
 283     /**
 284      * DOCUMENT ME!
 285      *
 286      * @return DOCUMENT ME!
 287      */
 288     public int size() {
 289         Long result = (Long) getHibernateTemplate()
 290             .findByNamedQuery(QUERY_COUNT_USERS).get(0);
 291
 292         return result.intValue();
 293     }
 294 }