Coverage Report - org.apache.turbine.services.security.ldap.LDAPUser
 
Classes in this File Line Coverage Branch Coverage Complexity
LDAPUser
0%
0/215
0%
0/96
2,13
 
 1  
 package org.apache.turbine.services.security.ldap;
 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.sql.Connection;
 25  
 import java.util.Hashtable;
 26  
 
 27  
 import javax.naming.NamingException;
 28  
 import javax.naming.directory.Attribute;
 29  
 import javax.naming.directory.Attributes;
 30  
 import javax.naming.directory.BasicAttribute;
 31  
 import javax.naming.directory.BasicAttributes;
 32  
 import javax.servlet.http.HttpSessionBindingEvent;
 33  
 
 34  
 import org.apache.commons.logging.Log;
 35  
 import org.apache.commons.logging.LogFactory;
 36  
 import org.apache.turbine.om.security.User;
 37  
 import org.apache.turbine.services.security.TurbineSecurity;
 38  
 
 39  
 /**
 40  
  * LDAPUser implements User and provides access to a user who accesses the
 41  
  * system via LDAP.
 42  
  *
 43  
  * @author <a href="mailto:cberry@gluecode.com">Craig D. Berry</a>
 44  
  * @author <a href="mailto:tadewunmi@gluecode.com">Tracy M. Adewunmi</a>
 45  
  * @author <a href="mailto:lflournoy@gluecode.com">Leonard J. Flournoy </a>
 46  
  * @author <a href="mailto:dlr@finemaltcoding.com">Daniel Rall</a>
 47  
  * @author <a href="mailto:hhernandez@itweb.com.mx">Humberto Hernandez</a>
 48  
  */
 49  
 public class LDAPUser implements User
 50  
 {
 51  
 
 52  
     /** Logging */
 53  0
     private static Log log = LogFactory.getLog(LDAPUser.class);
 54  
 
 55  
     /* A few attributes common to a User. */
 56  
 
 57  
     /** Date when the user was created */
 58  0
     private java.util.Date createDate = null;
 59  
 
 60  
     /** Date when the user was last accessed */
 61  0
     private java.util.Date lastAccessDate = null;
 62  
 
 63  
     /** timeout */
 64  0
     private int timeout = 15;
 65  
 
 66  
     /** This is data that will survive a servlet engine restart. */
 67  0
     private Hashtable permStorage = null;
 68  
 
 69  
     /** This is data that will not survive a servlet engine restart. */
 70  0
     private Hashtable tempStorage = null;
 71  
 
 72  
     /**
 73  
      * Constructor.
 74  
      * Create a new User and set the createDate.
 75  
      */
 76  
     public LDAPUser()
 77  0
     {
 78  0
         createDate = new java.util.Date();
 79  0
         tempStorage = new Hashtable(10);
 80  0
         permStorage = new Hashtable(10);
 81  0
         setHasLoggedIn(Boolean.FALSE);
 82  0
     }
 83  
 
 84  
     /**
 85  
      * Populates the user with values obtained from the LDAP Service.
 86  
      * This method could be redefined in subclasses.
 87  
      * @param attribs The attributes obtained from LDAP.
 88  
      * @throws NamingException if there was an error with JNDI.
 89  
      */
 90  
     public void setLDAPAttributes(Attributes attribs)
 91  
             throws NamingException
 92  
     {
 93  
 
 94  
         Attribute attr;
 95  
         String attrName;
 96  
 
 97  
         // Set the User id.
 98  0
         attrName = LDAPSecurityConstants.getUserIdAttribute();
 99  0
         if (attrName != null)
 100  
         {
 101  0
             attr = attribs.get(attrName);
 102  0
             if (attr != null && attr.get() != null)
 103  
             {
 104  
                 try
 105  
                 {
 106  
                     //setPrimaryKey(attr.get().toString());
 107  
                 }
 108  
                 catch (Exception ex)
 109  
                 {
 110  
                     log.error("Exception caught:", ex);
 111  0
                 }
 112  
             }
 113  
         }
 114  
 
 115  
         // Set the Username.
 116  0
         attrName = LDAPSecurityConstants.getNameAttribute();
 117  0
         if (attrName != null)
 118  
         {
 119  0
             attr = attribs.get(attrName);
 120  0
             if (attr != null && attr.get() != null)
 121  
             {
 122  0
                 setName(attr.get().toString());
 123  
             }
 124  
         }
 125  
         else
 126  
         {
 127  0
             log.error("There is no LDAP attribute for the username.");
 128  
         }
 129  
 
 130  
         // Set the Firstname.
 131  0
         attrName = LDAPSecurityConstants.getFirstNameAttribute();
 132  0
         if (attrName != null)
 133  
         {
 134  0
             attr = attribs.get(attrName);
 135  0
             if (attr != null && attr.get() != null)
 136  
             {
 137  0
                 setFirstName(attr.get().toString());
 138  
             }
 139  
         }
 140  
 
 141  
         // Set the Lastname.
 142  0
         attrName = LDAPSecurityConstants.getLastNameAttribute();
 143  0
         if (attrName != null)
 144  
         {
 145  0
             attr = attribs.get(attrName);
 146  0
             if (attr != null && attr.get() != null)
 147  
             {
 148  0
                 setLastName(attr.get().toString());
 149  
             }
 150  
         }
 151  
 
 152  
         // Set the E-Mail
 153  0
         attrName = LDAPSecurityConstants.getEmailAttribute();
 154  0
         if (attrName != null)
 155  
         {
 156  0
             attr = attribs.get(attrName);
 157  0
             if (attr != null && attr.get() != null)
 158  
             {
 159  0
                 setEmail(attr.get().toString());
 160  
             }
 161  
         }
 162  0
     }
 163  
 
 164  
     /**
 165  
      * Get the JNDI Attributes used to store the user in LDAP.
 166  
      * This method could be redefined in a subclass.
 167  
      *
 168  
      * @throws NamingException if there is a JNDI error.
 169  
      * @return The JNDI attributes of the user.
 170  
      */
 171  
     public Attributes getLDAPAttributes()
 172  
             throws NamingException
 173  
     {
 174  0
         Attributes attribs = new BasicAttributes();
 175  
         String attrName;
 176  
 
 177  
         // Set the objectClass
 178  0
         attrName = "objectClass";
 179  0
         if (attrName != null)
 180  
         {
 181  0
             Object value = "turbineUser";
 182  
 
 183  0
             if (value != null)
 184  
             {
 185  0
                 Attribute attr = new BasicAttribute(attrName, value);
 186  
 
 187  0
                 attribs.put(attr);
 188  
             }
 189  
         }
 190  
 
 191  
         // Set the User id.
 192  0
         attrName = LDAPSecurityConstants.getUserIdAttribute();
 193  0
         if (attrName != null)
 194  
         {
 195  0
             Object value = this.getIdAsObj();
 196  
 
 197  0
             if (value != null)
 198  
             {
 199  0
                 Attribute attr = new BasicAttribute(attrName, value);
 200  
 
 201  0
                 attribs.put(attr);
 202  
             }
 203  
         }
 204  
 
 205  
         // Set the Username.
 206  0
         attrName = LDAPSecurityConstants.getNameAttribute();
 207  0
         if (attrName != null)
 208  
         {
 209  0
             Object value = getName();
 210  
 
 211  0
             if (value != null)
 212  
             {
 213  0
                 Attribute attr = new BasicAttribute(attrName, value);
 214  
 
 215  0
                 attribs.put(attr);
 216  
             }
 217  
         }
 218  
 
 219  
         // Set the Firstname.
 220  0
         attrName = LDAPSecurityConstants.getFirstNameAttribute();
 221  0
         if (attrName != null)
 222  
         {
 223  0
             Object value = getFirstName();
 224  
 
 225  0
             if (value != null)
 226  
             {
 227  0
                 Attribute attr = new BasicAttribute(attrName, value);
 228  
 
 229  0
                 attribs.put(attr);
 230  
             }
 231  
         }
 232  
 
 233  
         // Set the Lastname.
 234  0
         attrName = LDAPSecurityConstants.getLastNameAttribute();
 235  0
         if (attrName != null)
 236  
         {
 237  0
             Object value = getLastName();
 238  
 
 239  0
             if (value != null)
 240  
             {
 241  0
                 Attribute attr = new BasicAttribute(attrName, value);
 242  
 
 243  0
                 attribs.put(attr);
 244  
             }
 245  
         }
 246  
 
 247  
         // Set the E-Mail.
 248  0
         attrName = LDAPSecurityConstants.getEmailAttribute();
 249  0
         if (attrName != null)
 250  
         {
 251  0
             Object value = getEmail();
 252  
 
 253  0
             if (value != null)
 254  
             {
 255  0
                 Attribute attr = new BasicAttribute(attrName, value);
 256  
 
 257  0
                 attribs.put(attr);
 258  
             }
 259  
         }
 260  
 
 261  
         // Set the Password
 262  0
         attrName = LDAPSecurityConstants.getPasswordAttribute();
 263  0
         if (attrName != null)
 264  
         {
 265  0
             Object value = getPassword();
 266  
 
 267  0
             if (value != null)
 268  
             {
 269  0
                 Attribute attr = new BasicAttribute(attrName, value);
 270  
 
 271  0
                 attribs.put(attr);
 272  
             }
 273  
         }
 274  
 
 275  0
         return attribs;
 276  
     }
 277  
 
 278  
     /**
 279  
      * Gets the distinguished name (DN) of the User.
 280  
      * This method could be redefined in a subclass.
 281  
      * @return The Distinguished Name of the user.
 282  
      */
 283  
     public String getDN()
 284  
     {
 285  0
         String filterAttribute = LDAPSecurityConstants.getNameAttribute();
 286  0
         String userBaseSearch = LDAPSecurityConstants.getBaseSearch();
 287  0
         String userName = getName();
 288  
 
 289  0
         String dn = filterAttribute + "=" + userName + "," + userBaseSearch;
 290  
 
 291  0
         return dn;
 292  
     }
 293  
 
 294  
     /**
 295  
      * Gets the access counter for a user during a session.
 296  
      *
 297  
      * @return The access counter for the user for the session.
 298  
      */
 299  
     public int getAccessCounterForSession()
 300  
     {
 301  
         try
 302  
         {
 303  0
             return ((Integer) getTemp(User.SESSION_ACCESS_COUNTER)).intValue();
 304  
         }
 305  0
         catch (Exception e)
 306  
         {
 307  0
             return 0;
 308  
         }
 309  
     }
 310  
 
 311  
     /**
 312  
      * Gets the access counter for a user from perm storage.
 313  
      *
 314  
      * @return The access counter for the user.
 315  
      */
 316  
     public int getAccessCounter()
 317  
     {
 318  
         try
 319  
         {
 320  0
             return ((Integer) getPerm(User.ACCESS_COUNTER)).intValue();
 321  
         }
 322  0
         catch (Exception e)
 323  
         {
 324  0
             return 0;
 325  
         }
 326  
     }
 327  
 
 328  
     /**
 329  
      * Gets the create date for this User.  This is the time at which
 330  
      * the user object was created.
 331  
      *
 332  
      * @return A Java Date with the date of creation for the user.
 333  
      */
 334  
     public java.util.Date getCreateDate()
 335  
     {
 336  0
         return createDate;
 337  
     }
 338  
 
 339  
     /**
 340  
      * Returns the value of Confirmed variable
 341  
      * @return the confirm value.
 342  
      */
 343  
     public String getConfirmed()
 344  
     {
 345  0
         String tmp = null;
 346  
 
 347  0
         tmp = (String) getPerm(User.CONFIRM_VALUE);
 348  0
         if (tmp != null && tmp.length() == 0)
 349  
         {
 350  0
             tmp = null;
 351  
         }
 352  0
         return tmp;
 353  
     }
 354  
 
 355  
     /**
 356  
      * Returns the Email for this user.  If this is defined, then
 357  
      * the user is considered logged in.
 358  
      *
 359  
      * @return A String with the user's Email.
 360  
      */
 361  
     public String getEmail()
 362  
     {
 363  0
         String tmp = null;
 364  
 
 365  0
         tmp = (String) getPerm(User.EMAIL);
 366  0
         if (tmp != null && tmp.length() == 0)
 367  
         {
 368  0
             tmp = null;
 369  
         }
 370  0
         return tmp;
 371  
     }
 372  
 
 373  
     /**
 374  
      * Gets the last access date for this User.  This is the last time
 375  
      * that the user object was referenced.
 376  
      *
 377  
      * @return A Java Date with the last access date for the user.
 378  
      */
 379  
     public java.util.Date getLastAccessDate()
 380  
     {
 381  0
         if (lastAccessDate == null)
 382  
         {
 383  0
             setLastAccessDate();
 384  
         }
 385  0
         return lastAccessDate;
 386  
     }
 387  
 
 388  
     /**
 389  
      * Get last login date/time for this user.
 390  
      *
 391  
      * @return A Java Date with the last login date for the user.
 392  
      */
 393  
     public java.util.Date getLastLogin()
 394  
     {
 395  0
         return (java.util.Date) getPerm(User.LAST_LOGIN);
 396  
     }
 397  
 
 398  
     /**
 399  
      * Get password for this user.
 400  
      *
 401  
      * @return A String with the password for the user.
 402  
      */
 403  
     public String getPassword()
 404  
     {
 405  0
         return (String) getPerm(User.PASSWORD);
 406  
     }
 407  
 
 408  
     /**
 409  
      * Get an object from permanent storage.
 410  
      * @param name The object's name.
 411  
      * @return An Object with the given name.
 412  
      */
 413  
     public Object getPerm(String name)
 414  
     {
 415  0
         return permStorage.get(name);
 416  
     }
 417  
 
 418  
     /**
 419  
      * Get an object from permanent storage; return default if value
 420  
      * is null.
 421  
      *
 422  
      * @param name The object's name.
 423  
      * @param def A default value to return.
 424  
      * @return An Object with the given name.
 425  
      */
 426  
     public Object getPerm(String name, Object def)
 427  
     {
 428  
         try
 429  
         {
 430  0
             Object val = permStorage.get(name);
 431  
 
 432  0
             if (val == null)
 433  
             {
 434  0
                 return def;
 435  
             }
 436  0
             return val;
 437  
         }
 438  0
         catch (Exception e)
 439  
         {
 440  0
             return def;
 441  
         }
 442  
     }
 443  
 
 444  
     /**
 445  
      * This should only be used in the case where we want to save the
 446  
      * data to the database.
 447  
      *
 448  
      * @return A Hashtable.
 449  
      */
 450  
     public Hashtable getPermStorage()
 451  
     {
 452  0
         if (this.permStorage == null)
 453  
         {
 454  0
             this.permStorage = new Hashtable();
 455  
         }
 456  0
         return this.permStorage;
 457  
     }
 458  
 
 459  
     /**
 460  
      * Get an object from temporary storage.
 461  
      *
 462  
      * @param name The object's name.
 463  
      * @return An Object with the given name.
 464  
      */
 465  
     public Object getTemp(String name)
 466  
     {
 467  0
         return tempStorage.get(name);
 468  
     }
 469  
 
 470  
     /**
 471  
      * Get an object from temporary storage; return default if value
 472  
      * is null.
 473  
      *
 474  
      * @param name The object's name.
 475  
      * @param def A default value to return.
 476  
      * @return An Object with the given name.
 477  
      */
 478  
     public Object getTemp(String name, Object def)
 479  
     {
 480  
         Object val;
 481  
 
 482  
         try
 483  
         {
 484  0
             val = tempStorage.get(name);
 485  0
             if (val == null)
 486  
             {
 487  0
                 val = def;
 488  
             }
 489  
         }
 490  0
         catch (Exception e)
 491  
         {
 492  0
             val = def;
 493  0
         }
 494  0
         return val;
 495  
     }
 496  
 
 497  
     /**
 498  
      * A User object can have a variable Timeout, which is defined in
 499  
      * minutes.  If the user has been timed out, then the
 500  
      * hasLoggedIn() value will return false.
 501  
      *
 502  
      * @return An int specifying the timeout.
 503  
      */
 504  
     public int getTimeout()
 505  
     {
 506  0
         return this.timeout;
 507  
     }
 508  
 
 509  
 
 510  
     /**
 511  
      * Returns the first name for this user.  If this is defined, then
 512  
      * the user is considered logged in.
 513  
      *
 514  
      * @return A String with the user's first name.
 515  
      */
 516  
     public String getFirstName()
 517  
     {
 518  0
         String tmp = null;
 519  
 
 520  0
         tmp = (String) getPerm(User.FIRST_NAME);
 521  0
         if (tmp != null && tmp.length() == 0)
 522  
         {
 523  0
             tmp = null;
 524  
         }
 525  0
         return tmp;
 526  
     }
 527  
 
 528  
     /**
 529  
      * Returns the last name for this user.  If this is defined, then
 530  
      * the user is considered logged in.
 531  
      *
 532  
      * @return A String with the user's last name.
 533  
      */
 534  
     public String getLastName()
 535  
     {
 536  0
         String tmp = null;
 537  
 
 538  0
         tmp = (String) getPerm(User.LAST_NAME);
 539  0
         if (tmp != null && tmp.length() == 0)
 540  
         {
 541  0
             tmp = null;
 542  
         }
 543  0
         return tmp;
 544  
     }
 545  
 
 546  
     /**
 547  
      * The user is considered logged in if they have not timed out.
 548  
      *
 549  
      * @return True if the user has logged in.
 550  
      */
 551  
     public boolean hasLoggedIn()
 552  
     {
 553  0
         Boolean tmp = getHasLoggedIn();
 554  
 
 555  0
         if (tmp != null && tmp.booleanValue())
 556  
         {
 557  0
             return true;
 558  
         }
 559  
         else
 560  
         {
 561  0
             return false;
 562  
         }
 563  
     }
 564  
 
 565  
     /**
 566  
      * This method reports whether or not the user has been confirmed
 567  
      * in the system by checking the <code>CONFIRM_VALUE</code>
 568  
      * column to see if it is equal to <code>CONFIRM_DATA</code>.
 569  
      *
 570  
      * @return True if the user has been confirmed.
 571  
      */
 572  
     public boolean isConfirmed()
 573  
     {
 574  0
         return ((String) getTemp(CONFIRM_VALUE, "")).equals(CONFIRM_DATA);
 575  
     }
 576  
 
 577  
     /**
 578  
      * Increments the permanent hit counter for the user.
 579  
      */
 580  
     public void incrementAccessCounter()
 581  
     {
 582  0
         setAccessCounter(getAccessCounter() + 1);
 583  0
     }
 584  
 
 585  
     /**
 586  
      * Increments the session hit counter for the user.
 587  
      */
 588  
     public void incrementAccessCounterForSession()
 589  
     {
 590  0
         setAccessCounterForSession(getAccessCounterForSession() + 1);
 591  0
     }
 592  
 
 593  
     /**
 594  
      * Remove an object from temporary storage and return the object.
 595  
      *
 596  
      * @param name The name of the object to remove.
 597  
      * @return An Object.
 598  
      */
 599  
     public Object removeTemp(String name)
 600  
     {
 601  0
         return tempStorage.remove(name);
 602  
     }
 603  
 
 604  
     /**
 605  
      * Sets the access counter for a user, saved in perm storage.
 606  
      *
 607  
      * @param cnt The new count.
 608  
      */
 609  
     public void setAccessCounter(int cnt)
 610  
     {
 611  0
         setPerm(User.ACCESS_COUNTER, new Integer(cnt));
 612  0
     }
 613  
 
 614  
     /**
 615  
      * Sets the session access counter for a user, saved in temp
 616  
      * storage.
 617  
      *
 618  
      * @param cnt The new count.
 619  
      */
 620  
     public void setAccessCounterForSession(int cnt)
 621  
     {
 622  0
         setTemp(User.SESSION_ACCESS_COUNTER, new Integer(cnt));
 623  0
     }
 624  
 
 625  
     /**
 626  
      * Set the users confirmed variable
 627  
      *
 628  
      * @param confirm The new confim value.
 629  
      */
 630  
     public void setConfirmed(String confirm)
 631  
     {
 632  0
         getPerm(User.CONFIRM_VALUE, confirm);
 633  0
     }
 634  
 
 635  
     /**
 636  
      * Sets the last access date for this User. This is the last time
 637  
      * that the user object was referenced.
 638  
      */
 639  
     public void setLastAccessDate()
 640  
     {
 641  0
         lastAccessDate = new java.util.Date();
 642  0
     }
 643  
 
 644  
     /**
 645  
      * Sets the create date for this User. This is the time at which
 646  
      * the user object was created.
 647  
      *
 648  
      * @param date The create date.
 649  
      */
 650  
     public void setCreateDate(java.util.Date date)
 651  
     {
 652  0
         createDate = date;
 653  0
     }
 654  
 
 655  
     /**
 656  
      * Set the users Email
 657  
      *
 658  
      * @param email The new email.
 659  
      */
 660  
     public void setEmail(String email)
 661  
     {
 662  0
         setPerm(User.EMAIL, email);
 663  0
     }
 664  
 
 665  
     /**
 666  
      * Set the users First Name
 667  
      *
 668  
      * @param fname The new firstname.
 669  
      */
 670  
     public void setFirstName(String fname)
 671  
     {
 672  0
         setPerm(User.FIRST_NAME, fname);
 673  0
     }
 674  
 
 675  
     /**
 676  
      * Set last login date/time.
 677  
      *
 678  
      * @param date The last login date.
 679  
      */
 680  
     public void setLastLogin(java.util.Date date)
 681  
     {
 682  0
         setPerm(User.LAST_LOGIN, date);
 683  0
     }
 684  
 
 685  
     /**
 686  
      * Set the users Last Name
 687  
      * Sets the last name for this user.
 688  
      *
 689  
      * @param lname The new lastname.
 690  
      */
 691  
     public void setLastName(String lname)
 692  
     {
 693  0
         setPerm(User.LAST_NAME, lname);
 694  0
     }
 695  
 
 696  
     /**
 697  
      * Set password.
 698  
      *
 699  
      * @param password The new password.
 700  
      */
 701  
     public void setPassword(String password)
 702  
     {
 703  0
         setPerm(User.PASSWORD, password);
 704  0
     }
 705  
 
 706  
     /**
 707  
      * Put an object into permanent storage.
 708  
      *
 709  
      * @param name The object's name.
 710  
      * @param value The object.
 711  
      */
 712  
     public void setPerm(String name, Object value)
 713  
     {
 714  0
         permStorage.put(name, value);
 715  0
     }
 716  
 
 717  
     /**
 718  
      * This should only be used in the case where we want to save the
 719  
      * data to the database.
 720  
      *
 721  
      * @param stuff A Hashtable.
 722  
      */
 723  
     public void setPermStorage(Hashtable stuff)
 724  
     {
 725  0
         this.permStorage = stuff;
 726  0
     }
 727  
 
 728  
     /**
 729  
      * This should only be used in the case where we want to save the
 730  
      * data to the database.
 731  
      *
 732  
      * @return A Hashtable.
 733  
      */
 734  
     public Hashtable getTempStorage()
 735  
     {
 736  0
         if (this.tempStorage == null)
 737  
         {
 738  0
             this.tempStorage = new Hashtable();
 739  
         }
 740  0
         return this.tempStorage;
 741  
     }
 742  
 
 743  
     /**
 744  
      * This should only be used in the case where we want to save the
 745  
      * data to the database.
 746  
      *
 747  
      * @param storage A Hashtable.
 748  
      */
 749  
     public void setTempStorage(Hashtable storage)
 750  
     {
 751  0
         this.tempStorage = storage;
 752  0
     }
 753  
 
 754  
     /**
 755  
      * This gets whether or not someone has logged in.  hasLoggedIn()
 756  
      * returns this value as a boolean.  This is private because you
 757  
      * should use hasLoggedIn() instead.
 758  
      *
 759  
      * @return True if someone has logged in.
 760  
      */
 761  
     private Boolean getHasLoggedIn()
 762  
     {
 763  0
         return (Boolean) getTemp(User.HAS_LOGGED_IN);
 764  
     }
 765  
 
 766  
     /**
 767  
      * This sets whether or not someone has logged in.  hasLoggedIn()
 768  
      * returns this value.
 769  
      *
 770  
      * @param value Whether someone has logged in or not.
 771  
      */
 772  
     public void setHasLoggedIn(Boolean value)
 773  
     {
 774  0
         setTemp(User.HAS_LOGGED_IN, value);
 775  0
     }
 776  
 
 777  
     /**
 778  
      * Put an object into temporary storage.
 779  
      *
 780  
      * @param name The object's name.
 781  
      * @param value The object.
 782  
      */
 783  
     public void setTemp(String name, Object value)
 784  
     {
 785  0
         tempStorage.put(name, value);
 786  0
     }
 787  
 
 788  
     /**
 789  
      * A User object can have a variable Timeout which is defined in
 790  
      * minutes.  If the user has been timed out, then the
 791  
      * hasLoggedIn() value will return false.
 792  
      *
 793  
      * @param time The user's timeout.
 794  
      */
 795  
     public void setTimeout(int time)
 796  
     {
 797  0
         this.timeout = time;
 798  0
     }
 799  
 
 800  
     /**
 801  
      * Updates the last login date in the database.
 802  
      *
 803  
      * @exception Exception a generic exception.
 804  
      */
 805  
     public void updateLastLogin() throws Exception
 806  
     {
 807  0
         setPerm(User.LAST_LOGIN, new java.util.Date());
 808  0
     }
 809  
 
 810  
     /**
 811  
      * Implement this method if you wish to be notified when the User
 812  
      * has been Bound to the session.
 813  
      *
 814  
      * @param hsbe The HttpSessionBindingEvent.
 815  
      */
 816  
     public void valueBound(HttpSessionBindingEvent hsbe)
 817  
     {
 818  
         // Do not currently need this method.
 819  0
     }
 820  
 
 821  
     /**
 822  
      * Implement this method if you wish to be notified when the User
 823  
      * has been Unbound from the session.
 824  
      *
 825  
      * @param hsbe The HttpSessionBindingEvent.
 826  
      */
 827  
     public void valueUnbound(HttpSessionBindingEvent hsbe)
 828  
     {
 829  
         try
 830  
         {
 831  0
             if (hasLoggedIn())
 832  
             {
 833  0
                 TurbineSecurity.saveUser(this);
 834  
             }
 835  
         }
 836  0
         catch (Exception e)
 837  
         {
 838  0
             log.error("BaseUser.valueUnbobund(): "
 839  
                     + e.getMessage());
 840  0
             log.error(e);
 841  
 
 842  
             // To prevent messages being lost in case the logging system
 843  
             // goes away before sessions get unbound on servlet container
 844  
             // shutdown, print the stcktrace to the container's console.
 845  0
             ByteArrayOutputStream ostr = new ByteArrayOutputStream();
 846  
 
 847  0
             e.printStackTrace(new PrintWriter(ostr, true));
 848  0
             String stackTrace = ostr.toString();
 849  
 
 850  0
             System.out.println(stackTrace);
 851  0
         }
 852  0
     }
 853  
 
 854  
     /**
 855  
      * Returns the username for this user.  If this is defined, then
 856  
      * the user is considered logged in.
 857  
      *
 858  
      * @return A String with the username.
 859  
      */
 860  
     public String getName()
 861  
     {
 862  0
         String tmp = null;
 863  
 
 864  0
         tmp = (String) getPerm(User.USERNAME);
 865  0
         if (tmp != null && tmp.length() == 0)
 866  
         {
 867  0
             tmp = null;
 868  
         }
 869  0
         return tmp;
 870  
     }
 871  
 
 872  
     /**
 873  
      * Set the users name.
 874  
      * @param name the name of the User.
 875  
      */
 876  
     public void setName(String name)
 877  
     {
 878  0
                 setPerm(User.USERNAME, name);
 879  0
     }
 880  
 
 881  
     /**
 882  
      * Not implemented.
 883  
      * @return 0
 884  
      */
 885  
     public int getId()
 886  
     {
 887  0
         return 0;
 888  
     }
 889  
 
 890  
     /**
 891  
      * Not implemented.
 892  
      * @return null
 893  
      */
 894  
     public Integer getIdAsObj()
 895  
     {
 896  0
         return new Integer(0);
 897  
     }
 898  
 
 899  
     /**
 900  
      * Not implemented.
 901  
      *
 902  
      * @param id The id of the User.
 903  
      */
 904  
     public void setId(int id)
 905  
     {
 906  0
     }
 907  
 
 908  
     /**
 909  
      * Saves this object to the data store.
 910  
      * @throws Exception if it cannot be saved
 911  
      */
 912  
     public void save()
 913  
             throws Exception
 914  
     {
 915  0
         if (TurbineSecurity.accountExists(this))
 916  
         {
 917  0
             TurbineSecurity.saveUser(this);
 918  
         }
 919  
         else
 920  
         {
 921  0
             TurbineSecurity.addUser(this, getPassword());
 922  
         }
 923  0
     }
 924  
 
 925  
     /**
 926  
      * not implemented
 927  
      *
 928  
      * @param conn the database connection
 929  
      * @throws Exception if there is an error
 930  
      */
 931  
     public void save(Connection conn) throws Exception
 932  
     {
 933  0
         throw new Exception("not implemented");
 934  
     }
 935  
 
 936  
     /**
 937  
      * not implemented
 938  
      *
 939  
      * @param dbname the database name
 940  
      * @throws Exception if there is an error
 941  
      */
 942  
     public void save(String dbname) throws Exception
 943  
     {
 944  0
         throw new Exception("not implemented");
 945  
     }
 946  
 
 947  
 }