View Javadoc

    1   package org.apache.turbine.om.security;
    2
    3
    4   /*
    5    * Licensed to the Apache Software Foundation (ASF) under one
    6    * or more contributor license agreements.  See the NOTICE file
    7    * distributed with this work for additional information
    8    * regarding copyright ownership.  The ASF licenses this file
    9    * to you under the Apache License, Version 2.0 (the
    10   * "License"); you may not use this file except in compliance
    11   * with the License.  You may obtain a copy of the License at
    12   *
    13   *   http://www.apache.org/licenses/LICENSE-2.0
    14   *
    15   * Unless required by applicable law or agreed to in writing,
    16   * software distributed under the License is distributed on an
    17   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    18   * KIND, either express or implied.  See the License for the
    19   * specific language governing permissions and limitations
    20   * under the License.
    21   */
    22
    23
    24  import java.sql.Connection;
    25  import java.util.Date;
    26  import java.util.Hashtable;
    27
    28  import javax.servlet.http.HttpSessionBindingEvent;
    29
    30  import org.apache.commons.logging.Log;
    31  import org.apache.commons.logging.LogFactory;
    32  import org.apache.turbine.services.security.TurbineSecurity;
    33
    34  /**
    35   * A generic implementation of User interface.
    36   *
    37   * This basic implementation contains the functionality that is
    38   * expected to be common among all User implementations.
    39   * You are welcome to extend this class if you wish to have
    40   * custom functionality in your user objects (like accessor methods
    41   * for custom attributes). <b>Note</b> that implementing a different scheme
    42   * of user data storage normally involves writing an implementation of
    43   * {@link org.apache.turbine.services.security.UserManager} interface.
    44   *
    45   * @author <a href="mailto:josh@stonecottage.com">Josh Lucas</a>
    46   * @author <a href="mailto:jon@collab.net">Jon S. Stevens</a>
    47   * @author <a href="mailto:john.mcnally@clearink.com">John D. McNally</a>
    48   * @author <a href="mailto:frank.kim@clearink.com">Frank Y. Kim</a>
    49   * @author <a href="mailto:cberry@gluecode.com">Craig D. Berry</a>
    50   * @author <a href="mailto:epugh@upstate.com">Eric Pugh</a>
    51   * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
    52   * @version $Id: TurbineUser.java 1078552 2011-03-06 19:58:46Z tv $
    53   */
    54  public class TurbineUser extends SecurityObject<User> implements User
    55  {
    56      /** Serial version */
    57      private static final long serialVersionUID = 6380024466902321258L;
    58
    59      /** Logging */
    60      private static Log log = LogFactory.getLog(TurbineUser.class);
    61
    62      /** The date on which the user account was created. */
    63      private Date createDate = null;
    64
    65      /** The date on which the user last accessed the application. */
    66      private Date lastAccessDate = null;
    67
    68      /** This is data that will survive a servlet engine restart. */
    69      private Hashtable<String, Object> permStorage = null;
    70
    71      /** This is data that will not survive a servlet engine restart. */
    72      private Hashtable<String, Object> tempStorage = null;
    73
    74      /**
    75       * Constructor.
    76       *
    77       * Create a new User and set the createDate.
    78       */
    79      public TurbineUser()
    80      {
    81          super();
    82          createDate = new Date();
    83          setHasLoggedIn(Boolean.FALSE);
    84      }
    85
    86      /**
    87       * Gets the access counter for a user during a session.
    88       *
    89       * @return The access counter for the user for the session.
    90       */
    91      public int getAccessCounterForSession()
    92      {
    93          try
    94          {
    95              return ((Integer) getTemp(User.SESSION_ACCESS_COUNTER)).intValue();
    96          }
    97          catch (Exception e)
    98          {
    99              return 0;
    100         }
    101     }
    102
    103     /**
    104      * Gets the access counter for a user from perm storage.
    105      *
    106      * @return The access counter for the user.
    107      */
    108     public int getAccessCounter()
    109     {
    110         try
    111         {
    112             return ((Integer) getPerm(User.ACCESS_COUNTER)).intValue();
    113         }
    114         catch (Exception e)
    115         {
    116             return 0;
    117         }
    118     }
    119
    120     /**
    121      * Gets the create date for this User.  This is the time at which
    122      * the user object was created.
    123      *
    124      * @return A Java Date with the date of creation for the user.
    125      */
    126     public java.util.Date getCreateDate()
    127     {
    128         return createDate;
    129     }
    130
    131     /**
    132      * Gets the last access date for this User.  This is the last time
    133      * that the user object was referenced.
    134      *
    135      * @return A Java Date with the last access date for the user.
    136      */
    137     public java.util.Date getLastAccessDate()
    138     {
    139         if (lastAccessDate == null)
    140         {
    141             setLastAccessDate();
    142         }
    143         return lastAccessDate;
    144     }
    145
    146     /**
    147      * Get last login date/time for this user.
    148      *
    149      * @return A Java Date with the last login date for the user.
    150      */
    151     public java.util.Date getLastLogin()
    152     {
    153         return (java.util.Date) getPerm(User.LAST_LOGIN);
    154     }
    155
    156     /**
    157      * Get password for this user.
    158      *
    159      * @return A String with the password for the user.
    160      */
    161     public String getPassword()
    162     {
    163         return (String) getPerm(User.PASSWORD);
    164     }
    165
    166     /**
    167      * Get an object from permanent storage.
    168      *
    169      * @param name The object's name.
    170      * @return An Object with the given name, or null if not found.
    171      */
    172     public Object getPerm(String name)
    173     {
    174         return getPerm(name,null);
    175     }
    176
    177     /**
    178      * Get an object from permanent storage; return default if value
    179      * is null.
    180      *
    181      * @param name The object's name.
    182      * @param def A default value to return.
    183      * @return An Object with the given name.
    184      */
    185     public Object getPerm(String name, Object def)
    186     {
    187         Object val;
    188         try
    189         {
    190             val = getPermStorage().get(name);
    191             if (val == null)
    192             {
    193                 val = def;
    194             }
    195         }
    196         catch (Exception e)
    197         {
    198             val = def;
    199         }
    200         return val;
    201     }
    202
    203     /**
    204      * This should only be used in the case where we want to save the
    205      * data to the database.
    206      *
    207      * @return A Hashtable.
    208      */
    209     public Hashtable<String, Object> getPermStorage()
    210     {
    211         if (permStorage == null)
    212         {
    213             permStorage = new Hashtable<String, Object>(10);
    214         }
    215         return permStorage;
    216     }
    217
    218     /**
    219      * Get an object from temporary storage; return null if the
    220      * object can't be found.
    221      *
    222      * @param name The object's name.
    223      * @return An Object with the given name.
    224      */
    225     public Object getTemp(String name)
    226     {
    227         return getTemp(name, null);
    228     }
    229
    230     /**
    231      * Get an object from temporary storage; return default if value
    232      * is null.
    233      *
    234      * @param name The object's name.
    235      * @param def A default value to return.
    236      * @return An Object with the given name.
    237      */
    238     public Object getTemp(String name, Object def)
    239     {
    240         Object val;
    241         try
    242         {
    243             val = getTempStorage().get(name);
    244             if (val == null)
    245             {
    246                 val = def;
    247             }
    248
    249         }
    250         catch (Exception e)
    251         {
    252             val = def;
    253         }
    254         return val;
    255     }
    256
    257
    258     /**
    259      * Returns the first name for this user.
    260      *
    261      * @return A String with the user's first name.
    262      */
    263     public String getFirstName()
    264     {
    265         String tmp = null;
    266         try
    267         {
    268             tmp = (String) getPerm(User.FIRST_NAME);
    269             if(tmp.length() == 0)
    270             {
    271                 tmp = null;
    272             }
    273         }
    274         catch (Exception e)
    275         {
    276             // ignore
    277         }
    278         return tmp;
    279     }
    280
    281     /**
    282      * Returns the last name for this user.
    283      *
    284      * @return A String with the user's last name.
    285      */
    286     public String getLastName()
    287     {
    288         String tmp = null;
    289         try
    290         {
    291             tmp = (String) getPerm(User.LAST_NAME);
    292             if (tmp.length() == 0)
    293                 tmp = null;
    294         }
    295         catch (Exception e)
    296         {
    297             // ignore
    298         }
    299         return tmp;
    300     }
    301
    302     /**
    303      * The user is considered logged in if they have not timed out.
    304      *
    305      * @return Whether the user has logged in.
    306      */
    307     public boolean hasLoggedIn()
    308     {
    309         Boolean loggedIn = getHasLoggedIn();
    310         return (loggedIn != null && loggedIn.booleanValue());
    311     }
    312
    313     /**
    314      * Returns the email address for this user.
    315      *
    316      * @return A String with the user's email address.
    317      */
    318     public String getEmail()
    319     {
    320         return (String) getPerm(User.EMAIL);
    321     }
    322
    323     /**
    324      * Increments the permanent hit counter for the user.
    325      */
    326     public void incrementAccessCounter()
    327     {
    328         setAccessCounter(getAccessCounter() + 1);
    329     }
    330
    331     /**
    332      * Increments the session hit counter for the user.
    333      */
    334     public void incrementAccessCounterForSession()
    335     {
    336         setAccessCounterForSession(getAccessCounterForSession() + 1);
    337     }
    338
    339     /**
    340      * Remove an object from temporary storage and return the object.
    341      *
    342      * @param name The name of the object to remove.
    343      * @return An Object.
    344      */
    345     public Object removeTemp(String name)
    346     {
    347         return getTempStorage().remove(name);
    348     }
    349
    350     /**
    351      * Sets the access counter for a user, saved in perm storage.
    352      *
    353      * @param cnt The new count.
    354      */
    355     public void setAccessCounter(int cnt)
    356     {
    357         setPerm(User.ACCESS_COUNTER, new Integer(cnt));
    358     }
    359
    360     /**
    361      * Sets the session access counter for a user, saved in temp
    362      * storage.
    363      *
    364      * @param cnt The new count.
    365      */
    366     public void setAccessCounterForSession(int cnt)
    367     {
    368         setTemp(User.SESSION_ACCESS_COUNTER, new Integer(cnt));
    369     }
    370
    371     /**
    372      * Sets the last access date for this User. This is the last time
    373      * that the user object was referenced.
    374      */
    375     public void setLastAccessDate()
    376     {
    377         lastAccessDate = new java.util.Date();
    378     }
    379
    380     /**
    381      * Sets the create date for this User. This is the time at which
    382      * the user object was created.
    383      *
    384      * @param date The create date.
    385      */
    386     public void setCreateDate(java.util.Date date)
    387     {
    388         createDate = date;
    389     }
    390
    391     /**
    392      * Set last login date/time.
    393      *
    394      * @param date The last login date.
    395      */
    396     public void setLastLogin(java.util.Date date)
    397     {
    398         setPerm(User.LAST_LOGIN, date);
    399     }
    400
    401     /**
    402      * Set password.
    403      *
    404      * @param password The new password.
    405      */
    406     public void setPassword(String password)
    407     {
    408         setPerm(User.PASSWORD, password);
    409     }
    410
    411     /**
    412      * Put an object into permanent storage. If the value is null,
    413      * it will convert that to a "" because the underlying storage
    414      * mechanism within TurbineUser is currently a Hashtable and
    415      * null is not a valid value.
    416      *
    417      * @param name The object's name.
    418      * @param value The object.
    419      */
    420     public void setPerm(String name, Object value)
    421     {
    422         getPermStorage().put(name, (value == null) ? "" : value);
    423     }
    424
    425     /**
    426      * This should only be used in the case where we want to save the
    427      * data to the database.
    428      *
    429      * @param permStorage A Hashtable.
    430      */
    431     public void setPermStorage(Hashtable<String, Object> permStorage)
    432     {
    433         this.permStorage = permStorage;
    434     }
    435
    436     /**
    437      * This should only be used in the case where we want to save the
    438      * data to the database.
    439      *
    440      * @return A Hashtable.
    441      */
    442     public Hashtable<String, Object> getTempStorage()
    443     {
    444         if (tempStorage == null)
    445         {
    446             tempStorage = new Hashtable<String, Object>(10);
    447         }
    448         return tempStorage;
    449     }
    450
    451     /**
    452      * This should only be used in the case where we want to save the
    453      * data to the database.
    454      *
    455      * @param storage A Hashtable.
    456      */
    457     public void setTempStorage(Hashtable<String, Object> tempStorage)
    458     {
    459         this.tempStorage = tempStorage;
    460     }
    461
    462     /**
    463      * This gets whether or not someone has logged in.  hasLoggedIn()
    464      * returns this value as a boolean.  This is private because you
    465      * should use hasLoggedIn() instead.
    466      *
    467      * @return True if someone has logged in.
    468      */
    469     private Boolean getHasLoggedIn()
    470     {
    471         return (Boolean) getTemp(User.HAS_LOGGED_IN);
    472     }
    473
    474     /**
    475      * This sets whether or not someone has logged in.  hasLoggedIn()
    476      * returns this value.
    477      *
    478      * @param value Whether someone has logged in or not.
    479      */
    480     public void setHasLoggedIn(Boolean value)
    481     {
    482         setTemp(User.HAS_LOGGED_IN, value);
    483     }
    484
    485     /**
    486      * Put an object into temporary storage. If the value is null,
    487      * it will convert that to a "" because the underlying storage
    488      * mechanism within TurbineUser is currently a Hashtable and
    489      * null is not a valid value.
    490      *
    491      * @param name The object's name.
    492      * @param value The object.
    493      */
    494     public void setTemp(String name, Object value)
    495     {
    496         getTempStorage().put(name, (value == null) ? "" : value);
    497     }
    498
    499
    500     /**
    501      * Sets the first name for this user.
    502      *
    503      * @param firstName User's first name.
    504      */
    505     public void setFirstName(String firstName)
    506     {
    507         setPerm(User.FIRST_NAME, firstName);
    508     }
    509
    510     /**
    511      * Sets the last name for this user.
    512      *
    513      * @param lastName User's last name.
    514      */
    515     public void setLastName(String lastName)
    516     {
    517         setPerm(User.LAST_NAME, lastName);
    518     }
    519
    520     /**
    521      * Sets the email address.
    522      *
    523      * @param address The email address.
    524      */
    525     public void setEmail(String address)
    526     {
    527         setPerm(User.EMAIL, address);
    528     }
    529
    530     /**
    531      * This method reports whether or not the user has been confirmed
    532      * in the system by checking the User.CONFIRM_VALUE
    533      * column in the users record to see if it is equal to
    534      * User.CONFIRM_DATA.
    535      *
    536      * @return True if the user has been confirmed.
    537      */
    538     public boolean isConfirmed()
    539     {
    540         String value = getConfirmed();
    541         return (value != null && value.equals(User.CONFIRM_DATA));
    542     }
    543
    544     /**
    545      * Sets the confirmation value. The value should
    546      * be either a random string or User.CONFIRM_DATA
    547      *
    548      * @param value The confirmation key value.
    549      */
    550     public void setConfirmed(String value)
    551     {
    552         String val = "";
    553         if (value != null)
    554         {
    555             val = value;
    556         }
    557         setPerm(User.CONFIRM_VALUE, val);
    558     }
    559
    560     /**
    561      * Gets the confirmation value.
    562      *
    563      * @return status The confirmation value for this User
    564      */
    565     public String getConfirmed()
    566     {
    567         return (String) getPerm(User.CONFIRM_VALUE);
    568     }
    569
    570     /**
    571      * Updates the last login date in the database.
    572      *
    573      * @exception Exception a generic exception.
    574      */
    575     public void updateLastLogin()
    576             throws Exception
    577     {
    578         setPerm(User.LAST_LOGIN, new java.util.Date());
    579     }
    580
    581     /**
    582      * Implement this method if you wish to be notified when the User
    583      * has been Bound to the session.
    584      *
    585      * @param hsbe The HttpSessionBindingEvent.
    586      */
    587     public void valueBound(HttpSessionBindingEvent hsbe)
    588     {
    589         // Currently we have no need for this method.
    590     }
    591
    592     /**
    593      * Implement this method if you wish to be notified when the User
    594      * has been Unbound from the session.
    595      *
    596      * @param hsbe The HttpSessionBindingEvent.
    597      */
    598     public void valueUnbound(HttpSessionBindingEvent hsbe)
    599     {
    600         try
    601         {
    602             if (hasLoggedIn())
    603             {
    604                 TurbineSecurity.saveOnSessionUnbind(this);
    605             }
    606         }
    607         catch (Exception e)
    608         {
    609             log.error("TurbineUser.valueUnbound(): " + e.getMessage(), e);
    610         }
    611     }
    612
    613     /**
    614      * Saves this object to the data store.
    615      */
    616     public void save()
    617             throws Exception
    618     {
    619         if (TurbineSecurity.accountExists(this))
    620         {
    621             TurbineSecurity.saveUser(this);
    622         }
    623         else
    624         {
    625             TurbineSecurity.addUser(this, getPassword());
    626         }
    627     }
    628
    629     /**
    630      * not implemented
    631      *
    632      * @param conn
    633      * @throws Exception
    634      */
    635     public void save(Connection conn) throws Exception
    636     {
    637         throw new Exception("not implemented");
    638     }
    639
    640     /**
    641      * not implemented
    642      *
    643      * @param dbname
    644      * @throws Exception
    645      */
    646     public void save(String dbname) throws Exception
    647     {
    648         throw new Exception("not implemented");
    649     }
    650
    651     /**
    652      * Returns the name of this user.  This will be the user name/
    653      * login name.
    654      *
    655      * @return The name of the user.
    656      */
    657     @Override
    658     public String getName()
    659     {
    660         return (String) getPerm(User.USERNAME);
    661     }
    662
    663     /**
    664      * Sets the name of this user.  This will be the user name/
    665      * login name.
    666      *
    667      * @param name The name of the object.
    668      */
    669     @Override
    670     public void setName(String name)
    671     {
    672         setPerm(User.USERNAME, name);
    673     }
    674 }