View Javadoc

    1   package org.apache.turbine.om.security;
    2
    3   /*
    4    * Licensed to the Apache Software Foundation (ASF) under one
    5    * or more contributor license agreements.  See the NOTICE file
    6    * distributed with this work for additional information
    7    * regarding copyright ownership.  The ASF licenses this file
    8    * to you under the Apache License, Version 2.0 (the
    9    * "License"); you may not use this file except in compliance
    10   * with the License.  You may obtain a copy of the License at
    11   *
    12   *   http://www.apache.org/licenses/LICENSE-2.0
    13   *
    14   * Unless required by applicable law or agreed to in writing,
    15   * software distributed under the License is distributed on an
    16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    17   * KIND, either express or implied.  See the License for the
    18   * specific language governing permissions and limitations
    19   * under the License.
    20   */
    21
    22  import java.io.ByteArrayOutputStream;
    23  import java.io.PrintWriter;
    24  import java.util.Date;
    25  import java.util.HashMap;
    26  import java.util.Map;
    27  import java.util.Set;
    28
    29  import javax.servlet.http.HttpSessionBindingEvent;
    30
    31  import org.apache.fulcrum.security.model.turbine.entity.TurbineUser;
    32  import org.apache.fulcrum.security.model.turbine.entity.TurbineUserGroupRole;
    33  import org.apache.fulcrum.security.util.DataBackendException;
    34  import org.apache.turbine.services.TurbineServices;
    35  import org.apache.turbine.services.security.SecurityService;
    36  import org.apache.turbine.util.ObjectUtils;
    37
    38  /**
    39   * This is the Default user implementation. It is a wrapper around
    40   * a TurbineUser object
    41   *
    42   * @author <a href="mailto:tv@apache.org">Thomas Vandahl</a>
    43   * @version $Id: TorqueUser.java 1199856 2011-11-09 17:06:04Z tv $
    44   */
    45
    46  public class DefaultUserImpl implements User
    47  {
    48      /** Serial version */
    49      private static final long serialVersionUID = -1866504873085624111L;
    50
    51      /** The date on which the user last accessed the application. */
    52      private Date lastAccessDate = null;
    53
    54      /** This is data that will survive a servlet engine restart. */
    55      private Map<String, Object> permStorage = null;
    56
    57      /** This is data that will not survive a servlet engine restart. */
    58      private Map<String, Object> tempStorage = null;
    59
    60      /** The Fulcrum user instance to delegate to */
    61      private TurbineUser userDelegate = null;
    62
    63      /**
    64       * Constructor
    65       *
    66       * @param user the user object to wrap
    67       */
    68      public DefaultUserImpl(TurbineUser user)
    69      {
    70          super();
    71          setUserDelegate( user );;
    72          setCreateDate(new Date());
    73          tempStorage = new HashMap<String, Object>(10);
    74          setHasLoggedIn(Boolean.FALSE);
    75      }
    76
    77      /**
    78       * Implement this method if you wish to be notified when the User
    79       * has been Bound to the session.
    80       *
    81       * @param hsbe Indication of value/session binding.
    82       */
    83      @Override
    84      public void valueBound(HttpSessionBindingEvent hsbe)
    85      {
    86          // Currently we have no need for this method.
    87      }
    88
    89      /**
    90       * Implement this method if you wish to be notified when the User
    91       * has been Unbound from the session.
    92       *
    93       * @param hsbe Indication of value/session unbinding.
    94       */
    95      @Override
    96      public void valueUnbound(HttpSessionBindingEvent hsbe)
    97      {
    98          try
    99          {
    100             if (hasLoggedIn())
    101             {
    102                 SecurityService securityService = (SecurityService)TurbineServices.getInstance().getService(SecurityService.SERVICE_NAME);
    103                 securityService.saveOnSessionUnbind(this);
    104             }
    105         }
    106         catch (Exception e)
    107         {
    108             //Log.error("TorqueUser.valueUnbound(): " + e.getMessage(), e);
    109
    110             // To prevent messages being lost in case the logging system
    111             // goes away before sessions get unbound on servlet container
    112             // shutdown, print the stacktrace to the container's console.
    113             ByteArrayOutputStream ostr = new ByteArrayOutputStream();
    114             e.printStackTrace(new PrintWriter(ostr, true));
    115             String stackTrace = ostr.toString();
    116             System.out.println(stackTrace);
    117         }
    118     }
    119
    120     /**
    121      * Get the Name of the SecurityEntity.
    122      *
    123      * @return The Name of the SecurityEntity.
    124      */
    125     @Override
    126     public String getName()
    127     {
    128         return userDelegate.getName();
    129     }
    130
    131     /**
    132      * Sets the Name of the SecurityEntity.
    133      *
    134      * @param name
    135      *            Name of the SecurityEntity.
    136      */
    137     @Override
    138     public void setName(String name)
    139     {
    140         userDelegate.setName(name);
    141     }
    142
    143     /**
    144      * Get the Id of the SecurityEntity.
    145      *
    146      * @return The Id of the SecurityEntity.
    147      */
    148     @Override
    149     public Object getId()
    150     {
    151         return userDelegate.getId();
    152     }
    153
    154     /**
    155      * Sets the Id of the SecurityEntity.
    156      *
    157      * @param id
    158      *            The new Id of the SecurityEntity
    159      */
    160     @Override
    161     public void setId(Object id)
    162     {
    163         userDelegate.setId(id);
    164     }
    165
    166     /**
    167      * Returns the user's password. This method should not be used by
    168      * the application directly, because it's meaning depends upon
    169      * the implementation of UserManager that manages this particular
    170      * user object. Some implementations will use this attribute for
    171      * storing a password encrypted in some way, other will not use
    172      * it at all, when user entered password is presented to some external
    173      * authority (like NT domain controller) to validate it.
    174      * See also {@link org.apache.turbine.services.security.UserManager#authenticate(User,String)}.
    175      *
    176      * @return A String with the password for the user.
    177      */
    178     @Override
    179     public String getPassword()
    180     {
    181         return userDelegate.getPassword();
    182     }
    183
    184     /**
    185      * Set password. Application should not use this method
    186      * directly, see {@link #getPassword()}.
    187      * See also {@link org.apache.turbine.services.security.UserManager#changePassword(User,String,String)}.
    188      *
    189      * @param password The new password.
    190      */
    191     @Override
    192     public void setPassword(String password)
    193     {
    194         userDelegate.setPassword(password);
    195     }
    196
    197     /**
    198      * Returns the first name for this user.
    199      *
    200      * @return A String with the user's first name.
    201      */
    202     @Override
    203     public String getFirstName()
    204     {
    205         return userDelegate.getFirstName();
    206     }
    207
    208     /**
    209      * Sets the first name for this user.
    210      *
    211      * @param firstName User's first name.
    212      */
    213     @Override
    214     public void setFirstName(String firstName)
    215     {
    216         userDelegate.setFirstName(firstName);
    217     }
    218
    219     /**
    220      * Returns the last name for this user.
    221      *
    222      * @return A String with the user's last name.
    223      */
    224     @Override
    225     public String getLastName()
    226     {
    227         return userDelegate.getLastName();
    228     }
    229
    230     /**
    231      * Sets the last name for this user.
    232      *
    233      * @param lastName User's last name.
    234      */
    235     @Override
    236     public void setLastName(String lastName)
    237     {
    238         userDelegate.setLastName(lastName);
    239     }
    240
    241     /**
    242      * Returns the email address for this user.
    243      *
    244      * @return A String with the user's email address.
    245      */
    246     @Override
    247     public String getEmail()
    248     {
    249         return userDelegate.getEmail();
    250     }
    251
    252     /**
    253      * Sets the email address.
    254      *
    255      * @param address The email address.
    256      */
    257     @Override
    258     public void setEmail(String address)
    259     {
    260         userDelegate.setEmail(address);
    261     }
    262
    263     /**
    264      * Returns the value of the objectdata for this user.
    265      * Objectdata is a storage area used
    266      * to store the permanent storage table from the User
    267      * object.
    268      *
    269      * @return The bytes in the objectdata for this user
    270      */
    271     @Override
    272     public byte[] getObjectdata()
    273     {
    274         return userDelegate.getObjectdata();
    275     }
    276
    277     /**
    278      * Sets the value of the objectdata for the user
    279      *
    280      * @param objectdata The new permanent storage for the user
    281      */
    282     @Override
    283     public void setObjectdata(byte[] objectdata)
    284     {
    285         userDelegate.setObjectdata(objectdata);
    286     }
    287
    288     /**
    289      * Get the User/Group/Role set associated with this entity
    290      *
    291      * @return a set of User/Group/Role relations
    292      * @throws DataBackendException
    293      */
    294     @Override
    295     public <T extends TurbineUserGroupRole> Set<T> getUserGroupRoleSet() throws DataBackendException
    296     {
    297         return userDelegate.getUserGroupRoleSet();
    298     }
    299
    300     /**
    301      * Set the User/Group/Role set associated with this entity
    302      *
    303      * @param userGroupRoleSet
    304      *            a set of User/Group/Role relations
    305      */
    306     @Override
    307     public <T extends TurbineUserGroupRole> void setUserGroupRoleSet(Set<T> userGroupRoleSet)
    308     {
    309         userDelegate.setUserGroupRoleSet(userGroupRoleSet);
    310     }
    311
    312     /**
    313      * Add a User/Group/Role relation to this entity
    314      *
    315      * @param userGroupRole
    316      *            a User/Group/Role relation to add
    317      * @throws DataBackendException
    318      */
    319     @Override
    320     public void addUserGroupRole(TurbineUserGroupRole userGroupRole) throws DataBackendException
    321     {
    322         userDelegate.addUserGroupRole(userGroupRole);
    323     }
    324
    325     /**
    326      * Remove a User/Group/Role relation from this entity
    327      *
    328      * @param userGroupRole
    329      *            a User/Group/Role relation to remove
    330      * @throws DataBackendException
    331      */
    332     @Override
    333     public void removeUserGroupRole(TurbineUserGroupRole userGroupRole) throws DataBackendException
    334     {
    335         userDelegate.removeUserGroupRole(userGroupRole);
    336     }
    337
    338     /**
    339      * Gets the access counter for a user from perm storage.
    340      *
    341      * @return The access counter for the user.
    342      */
    343     @Override
    344     public int getAccessCounter()
    345     {
    346         try
    347         {
    348             return ((Integer) getPerm(User.ACCESS_COUNTER)).intValue();
    349         }
    350         catch (Exception e)
    351         {
    352             return 0;
    353         }
    354     }
    355
    356     /**
    357      * Gets the access counter for a user during a session.
    358      *
    359      * @return The access counter for the user for the session.
    360      */
    361     @Override
    362     public int getAccessCounterForSession()
    363     {
    364         try
    365         {
    366             return ((Integer) getTemp(User.SESSION_ACCESS_COUNTER)).intValue();
    367         }
    368         catch (Exception e)
    369         {
    370             return 0;
    371         }
    372     }
    373
    374     /**
    375      * Increments the permanent hit counter for the user.
    376      */
    377     @Override
    378     public void incrementAccessCounter()
    379     {
    380         // Ugh. Race city, here I come...
    381         setAccessCounter(getAccessCounter() + 1);
    382     }
    383
    384     /**
    385      * Increments the session hit counter for the user.
    386      */
    387     @Override
    388     public void incrementAccessCounterForSession()
    389     {
    390         setAccessCounterForSession(getAccessCounterForSession() + 1);
    391     }
    392
    393     /**
    394      * Sets the access counter for a user, saved in perm storage.
    395      *
    396      * @param cnt The new count.
    397      */
    398     @Override
    399     public void setAccessCounter(int cnt)
    400     {
    401         setPerm(User.ACCESS_COUNTER, Integer.valueOf(cnt));
    402     }
    403
    404     /**
    405      * Sets the session access counter for a user, saved in temp
    406      * storage.
    407      *
    408      * @param cnt The new count.
    409      */
    410     @Override
    411     public void setAccessCounterForSession(int cnt)
    412     {
    413         setTemp(User.SESSION_ACCESS_COUNTER, Integer.valueOf(cnt));
    414     }
    415
    416     /**
    417      * Gets the last access date for this User.  This is the last time
    418      * that the user object was referenced.
    419      *
    420      * @return A Java Date with the last access date for the user.
    421      */
    422     @Override
    423     public java.util.Date getLastAccessDate()
    424     {
    425         if (lastAccessDate == null)
    426         {
    427             setLastAccessDate();
    428         }
    429         return lastAccessDate;
    430     }
    431
    432     /**
    433      * Sets the last access date for this User. This is the last time
    434      * that the user object was referenced.
    435      */
    436     @Override
    437     public void setLastAccessDate()
    438     {
    439         lastAccessDate = new java.util.Date();
    440     }
    441
    442     /**
    443      * Returns the permanent storage. This is implemented
    444      * as a Map
    445      *
    446      * @return A Map.
    447      */
    448     @Override
    449     public Map<String, Object> getPermStorage()
    450     {
    451         if (permStorage == null)
    452         {
    453             byte [] objectdata = getObjectdata();
    454
    455             if (objectdata != null)
    456             {
    457                 permStorage = ObjectUtils.deserialize(objectdata);
    458             }
    459
    460             if (permStorage == null)
    461             {
    462                 permStorage = new HashMap<String, Object>();
    463             }
    464         }
    465
    466         return permStorage;
    467     }
    468
    469     /**
    470      * This should only be used in the case where we want to make the
    471      * data persistent.
    472      *
    473      * @param permStorage A Map.
    474      */
    475     @Override
    476     public void setPermStorage(Map<String, Object> permStorage)
    477     {
    478         if (permStorage != null)
    479         {
    480             this.permStorage = permStorage;
    481         }
    482     }
    483
    484     /**
    485      * Returns the temporary storage. This is implemented
    486      * as a Map
    487      *
    488      * @return A Map.
    489      */
    490     @Override
    491     public Map<String, Object> getTempStorage()
    492     {
    493         if (tempStorage == null)
    494         {
    495             tempStorage = new HashMap<String, Object>();
    496         }
    497         return tempStorage;
    498     }
    499
    500     /**
    501      * This should only be used in the case where we want to save the
    502      * data to the database.
    503      *
    504      * @param tempStorage A Map.
    505      */
    506     @Override
    507     public void setTempStorage(Map<String, Object> tempStorage)
    508     {
    509         if (tempStorage != null)
    510         {
    511             this.tempStorage = tempStorage;
    512         }
    513     }
    514
    515     /**
    516      * Get an object from permanent storage.
    517      *
    518      * @param name The object's name.
    519      * @return An Object with the given name.
    520      */
    521     @Override
    522     public Object getPerm(String name)
    523     {
    524         return getPermStorage().get(name);
    525     }
    526
    527     /**
    528      * Get an object from permanent storage; return default if value
    529      * is null.
    530      *
    531      * @param name The object's name.
    532      * @param def A default value to return.
    533      * @return An Object with the given name.
    534      */
    535     @Override
    536     public Object getPerm(String name, Object def)
    537     {
    538         try
    539         {
    540             Object val = getPermStorage().get(name);
    541             return (val == null ? def : val);
    542         }
    543         catch (Exception e)
    544         {
    545             return def;
    546         }
    547     }
    548
    549     /**
    550      * Put an object into permanent storage.
    551      *
    552      * @param name The object's name.
    553      * @param value The object.
    554      */
    555     @Override
    556     public void setPerm(String name, Object value)
    557     {
    558         getPermStorage().put(name, value);
    559     }
    560
    561     /**
    562      * Get an object from temporary storage.
    563      *
    564      * @param name The object's name.
    565      * @return An Object with the given name.
    566      */
    567     @Override
    568     public Object getTemp(String name)
    569     {
    570         return getTempStorage().get(name);
    571     }
    572
    573     /**
    574      * Get an object from temporary storage; return default if value
    575      * is null.
    576      *
    577      * @param name The object's name.
    578      * @param def A default value to return.
    579      * @return An Object with the given name.
    580      */
    581     @Override
    582     public Object getTemp(String name, Object def)
    583     {
    584         Object val;
    585         try
    586         {
    587             val = getTempStorage().get(name);
    588             if (val == null)
    589             {
    590                 val = def;
    591             }
    592         }
    593         catch (Exception e)
    594         {
    595             val = def;
    596         }
    597         return val;
    598     }
    599
    600     /**
    601      * Put an object into temporary storage.
    602      *
    603      * @param name The object's name.
    604      * @param value The object.
    605      */
    606     @Override
    607     public void setTemp(String name, Object value)
    608     {
    609         getTempStorage().put(name, value);
    610     }
    611
    612     /**
    613      * Remove an object from temporary storage and return the object.
    614      *
    615      * @param name The name of the object to remove.
    616      * @return An Object.
    617      */
    618     @Override
    619     public Object removeTemp(String name)
    620     {
    621         return getTempStorage().remove(name);
    622     }
    623
    624     /**
    625      * Returns the confirm value of the user
    626      *
    627      * @return The confirm value of the user
    628      */
    629     @Override
    630     public String getConfirmed()
    631     {
    632         return (String) getPerm(User.CONFIRM_VALUE);
    633     }
    634
    635     /**
    636      * Sets the new confirm value of the user
    637      *
    638      * @param confirm The new confirm value of the user
    639      */
    640     @Override
    641     public void setConfirmed(String confirm)
    642     {
    643         setPerm(User.CONFIRM_VALUE, confirm);
    644     }
    645
    646     /**
    647      * Returns the creation date of the user
    648      *
    649      * @return The creation date of the user
    650      */
    651     @Override
    652     public java.util.Date getCreateDate()
    653     {
    654         return (java.util.Date)getPerm(CREATE_DATE, new java.util.Date());
    655     }
    656
    657     /**
    658      * Sets the new creation date of the user
    659      *
    660      * @param createDate The new creation date of the user
    661      */
    662     @Override
    663     public void setCreateDate(java.util.Date createDate)
    664     {
    665         setPerm(CREATE_DATE, createDate);
    666     }
    667
    668     /**
    669      * Returns the date of the last login of the user
    670      *
    671      * @return The date of the last login of the user
    672      */
    673     @Override
    674     public java.util.Date getLastLogin()
    675     {
    676         return (java.util.Date) getPerm(User.LAST_LOGIN);
    677     }
    678
    679     /**
    680      * Sets the new date of the last login of the user
    681      *
    682      * @param lastLogin The new the date of the last login of the user
    683      */
    684     @Override
    685     public void setLastLogin(java.util.Date lastLogin)
    686     {
    687         setPerm(User.LAST_LOGIN, lastLogin);
    688     }
    689
    690     /**
    691      * The user is considered logged in if they have not timed out.
    692      *
    693      * @return Whether the user has logged in.
    694      */
    695     @Override
    696     public boolean hasLoggedIn()
    697     {
    698         Boolean loggedIn = (Boolean) getTemp(User.HAS_LOGGED_IN);
    699         return (loggedIn != null && loggedIn.booleanValue());
    700     }
    701
    702     /**
    703      * This sets whether or not someone has logged in.  hasLoggedIn()
    704      * returns this value.
    705      *
    706      * @param value Whether someone has logged in or not.
    707      */
    708     @Override
    709     public void setHasLoggedIn(Boolean value)
    710     {
    711         setTemp(User.HAS_LOGGED_IN, value);
    712     }
    713
    714     /**
    715      * This method reports whether or not the user has been confirmed
    716      * in the system by checking the User.CONFIRM_VALUE
    717      * column in the users record to see if it is equal to
    718      * User.CONFIRM_DATA.
    719      *
    720      * @return True if the user has been confirmed.
    721      */
    722     @Override
    723     public boolean isConfirmed()
    724     {
    725         String value = getConfirmed();
    726         return (value != null && value.equals(User.CONFIRM_DATA));
    727     }
    728
    729     /**
    730      * Updates the last login date in the database.
    731      *
    732      * @throws Exception A generic exception.
    733      */
    734     @Override
    735     public void updateLastLogin()
    736         throws Exception
    737     {
    738         setLastLogin(new java.util.Date());
    739     }
    740
    741     /* (non-Javadoc)
    742 	 * @see org.apache.turbine.om.security.UserDelegate#getUserDelegate()
    743 	 */
    744     @Override
    745 	public TurbineUser getUserDelegate()
    746     {
    747         return userDelegate;
    748     }
    749
    750     /* (non-Javadoc)
    751 	 * @see org.apache.turbine.om.security.UserDelegate#setUserDelegate(org.apache.fulcrum.security.model.turbine.entity.TurbineUser)
    752 	 */
    753     @Override
    754 	public void setUserDelegate(TurbineUser userDelegate)
    755     {
    756         this.userDelegate = userDelegate;
    757     }
    758 }