Coverage report

  %line %branch
org.apache.turbine.om.security.TurbineUser
1% 
80% 

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

This report is generated by jcoverage, Maven and Maven JCoverage Plugin.