001 package org.apache.turbine.services.security.torque; 002 003 /* 004 * Licensed to the Apache Software Foundation (ASF) under one 005 * or more contributor license agreements. See the NOTICE file 006 * distributed with this work for additional information 007 * regarding copyright ownership. The ASF licenses this file 008 * to you under the Apache License, Version 2.0 (the 009 * "License"); you may not use this file except in compliance 010 * with the License. You may obtain a copy of the License at 011 * 012 * http://www.apache.org/licenses/LICENSE-2.0 013 * 014 * Unless required by applicable law or agreed to in writing, 015 * software distributed under the License is distributed on an 016 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 017 * KIND, either express or implied. See the License for the 018 * specific language governing permissions and limitations 019 * under the License. 020 */ 021 022 import java.beans.PropertyDescriptor; 023 024 import java.util.ArrayList; 025 import java.util.Iterator; 026 import java.util.List; 027 028 import org.apache.commons.configuration.Configuration; 029 030 import org.apache.commons.logging.Log; 031 import org.apache.commons.logging.LogFactory; 032 033 import org.apache.torque.TorqueException; 034 import org.apache.torque.om.Persistent; 035 import org.apache.torque.util.BasePeer; 036 import org.apache.torque.util.Criteria; 037 038 import org.apache.turbine.om.security.User; 039 import org.apache.turbine.services.InitializationException; 040 import org.apache.turbine.services.security.TurbineSecurity; 041 import org.apache.turbine.util.security.DataBackendException; 042 043 /** 044 * This class capsulates all direct Peer access for the User entities. 045 * It allows the exchange of the default Turbine supplied TurbineUserPeer 046 * class against a custom class. 047 * 048 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a> 049 * @version $Id: UserPeerManager.java 1096130 2011-04-23 10:37:19Z ludwig $ 050 */ 051 052 public class UserPeerManager 053 implements UserPeerManagerConstants 054 { 055 /** Serial UID */ 056 private static final long serialVersionUID = 6943046259921811593L; 057 058 /** The class of the Peer the TorqueSecurityService uses */ 059 private static Class userPeerClass = null; 060 061 /** The class name of the objects returned by the configured peer. */ 062 private static Class userObject = null; 063 064 /** The name of the Table used for Group Object queries */ 065 private static String tableName = null; 066 067 /** The name of the column used as "Name" Column */ 068 private static String nameColumn = null; 069 070 /** The name of the column used as "Id" Column */ 071 private static String idColumn = null; 072 073 /** The name of the column used as "Password" Column */ 074 private static String passwordColumn = null; 075 076 /** The name of the column used as "First name" Column */ 077 private static String firstNameColumn = null; 078 079 /** The name of the column used as "Last name" Column */ 080 private static String lastNameColumn = null; 081 082 /** The name of the column used as "Email" Column */ 083 private static String emailColumn = null; 084 085 /** The name of the column used as "Confirm" Column */ 086 private static String confirmColumn = null; 087 088 /** The name of the column used as "create date" Column */ 089 private static String createDateColumn = null; 090 091 /** The name of the column used as "last login" Column */ 092 private static String lastLoginColumn = null; 093 094 /** The name of the column used as "objectdata" Column */ 095 private static String objectdataColumn = null; 096 097 /** The "Name" property descriptor */ 098 private static PropertyDescriptor namePropDesc = null; 099 100 /** The "Id" property descriptor */ 101 private static PropertyDescriptor idPropDesc = null; 102 103 /** The "Password" property descriptor */ 104 private static PropertyDescriptor passwordPropDesc = null; 105 106 /** The "First name" property descriptor */ 107 private static PropertyDescriptor firstNamePropDesc = null; 108 109 /** The "Last name" property descriptor */ 110 private static PropertyDescriptor lastNamePropDesc = null; 111 112 /** The "Email" property descriptor */ 113 private static PropertyDescriptor emailPropDesc = null; 114 115 /** The "Confirm" property descriptor */ 116 private static PropertyDescriptor confirmPropDesc = null; 117 118 /** The "create date" property descriptor */ 119 private static PropertyDescriptor createDatePropDesc = null; 120 121 /** The "last login" property descriptor */ 122 private static PropertyDescriptor lastLoginPropDesc = null; 123 124 /** The "objectdata" property descriptor */ 125 private static PropertyDescriptor objectdataPropDesc = null; 126 127 /** Logging */ 128 static Log log = LogFactory.getLog(UserPeerManager.class); 129 130 /** 131 * Initializes the UserPeerManager, loading the class object for the 132 * Peer used to retrieve User objects 133 * 134 * @param conf The configuration object used to configure the Manager 135 * 136 * @exception InitializationException A problem occured during 137 * initialization 138 */ 139 140 public static void init(Configuration conf) 141 throws InitializationException 142 { 143 String userPeerClassName = conf.getString(USER_PEER_CLASS_KEY, 144 USER_PEER_CLASS_DEFAULT); 145 String userObjectName = null; 146 147 try 148 { 149 userPeerClass = Class.forName(userPeerClassName); 150 151 tableName = 152 (String) userPeerClass.getField("TABLE_NAME").get(null); 153 154 // 155 // We have either an user configured Object class or we use the 156 // default as supplied by the Peer class 157 // 158 159 // Default from Peer, can be overridden 160 161 userObject = getPersistenceClass(); 162 163 userObjectName = conf.getString(USER_CLASS_KEY, 164 userObject.getName()); 165 166 // Maybe the user set a new value... 167 userObject = Class.forName(userObjectName); 168 169 /* If any of the following Field queries fails, the user 170 * subsystem is unusable. So check this right here at init time, 171 * which saves us much time and hassle if it fails... 172 */ 173 174 nameColumn = (String) userPeerClass.getField( 175 conf.getString(USER_NAME_COLUMN_KEY, 176 USER_NAME_COLUMN_DEFAULT) 177 ).get(null); 178 179 idColumn = (String) userPeerClass.getField( 180 conf.getString(USER_ID_COLUMN_KEY, 181 USER_ID_COLUMN_DEFAULT) 182 ).get(null); 183 184 passwordColumn = (String) userPeerClass.getField( 185 conf.getString(USER_PASSWORD_COLUMN_KEY, 186 USER_PASSWORD_COLUMN_DEFAULT) 187 ).get(null); 188 189 firstNameColumn = (String) userPeerClass.getField( 190 conf.getString(USER_FIRST_NAME_COLUMN_KEY, 191 USER_FIRST_NAME_COLUMN_DEFAULT) 192 ).get(null); 193 194 lastNameColumn = (String) userPeerClass.getField( 195 conf.getString(USER_LAST_NAME_COLUMN_KEY, 196 USER_LAST_NAME_COLUMN_DEFAULT) 197 ).get(null); 198 199 emailColumn = (String) userPeerClass.getField( 200 conf.getString(USER_EMAIL_COLUMN_KEY, 201 USER_EMAIL_COLUMN_DEFAULT) 202 ).get(null); 203 204 confirmColumn = (String) userPeerClass.getField( 205 conf.getString(USER_CONFIRM_COLUMN_KEY, 206 USER_CONFIRM_COLUMN_DEFAULT) 207 ).get(null); 208 209 createDateColumn = (String) userPeerClass.getField( 210 conf.getString(USER_CREATE_COLUMN_KEY, 211 USER_CREATE_COLUMN_DEFAULT) 212 ).get(null); 213 214 lastLoginColumn = (String) userPeerClass.getField( 215 conf.getString(USER_LAST_LOGIN_COLUMN_KEY, 216 USER_LAST_LOGIN_COLUMN_DEFAULT) 217 ).get(null); 218 219 objectdataColumn = (String) userPeerClass.getField( 220 conf.getString(USER_OBJECTDATA_COLUMN_KEY, 221 USER_OBJECTDATA_COLUMN_DEFAULT) 222 ).get(null); 223 224 namePropDesc = 225 new PropertyDescriptor(conf.getString( 226 USER_NAME_PROPERTY_KEY, 227 USER_NAME_PROPERTY_DEFAULT), 228 userObject); 229 230 idPropDesc = 231 new PropertyDescriptor(conf.getString( 232 USER_ID_PROPERTY_KEY, 233 USER_ID_PROPERTY_DEFAULT), 234 userObject); 235 236 passwordPropDesc = 237 new PropertyDescriptor(conf.getString( 238 USER_PASSWORD_PROPERTY_KEY, 239 USER_PASSWORD_PROPERTY_DEFAULT), 240 userObject); 241 242 firstNamePropDesc = 243 new PropertyDescriptor(conf.getString( 244 USER_FIRST_NAME_PROPERTY_KEY, 245 USER_FIRST_NAME_PROPERTY_DEFAULT), 246 userObject); 247 248 lastNamePropDesc = 249 new PropertyDescriptor(conf.getString( 250 USER_LAST_NAME_PROPERTY_KEY, 251 USER_LAST_NAME_PROPERTY_DEFAULT), 252 userObject); 253 254 emailPropDesc = 255 new PropertyDescriptor(conf.getString( 256 USER_EMAIL_PROPERTY_KEY, 257 USER_EMAIL_PROPERTY_DEFAULT), 258 userObject); 259 260 confirmPropDesc = 261 new PropertyDescriptor(conf.getString( 262 USER_CONFIRM_PROPERTY_KEY, 263 USER_CONFIRM_PROPERTY_DEFAULT), 264 userObject); 265 266 createDatePropDesc = 267 new PropertyDescriptor(conf.getString( 268 USER_CREATE_PROPERTY_KEY, 269 USER_CREATE_PROPERTY_DEFAULT), 270 userObject); 271 272 lastLoginPropDesc = 273 new PropertyDescriptor(conf.getString( 274 USER_LAST_LOGIN_PROPERTY_KEY, 275 USER_LAST_LOGIN_PROPERTY_DEFAULT), 276 userObject); 277 278 objectdataPropDesc = 279 new PropertyDescriptor(conf.getString( 280 USER_OBJECTDATA_PROPERTY_KEY, 281 USER_OBJECTDATA_PROPERTY_DEFAULT), 282 userObject); 283 } 284 catch (Exception e) 285 { 286 if (userPeerClassName == null || userPeerClass == null) 287 { 288 throw new InitializationException( 289 "Could not find UserPeer class (" 290 + userPeerClassName + ")", e); 291 } 292 if (tableName == null) 293 { 294 throw new InitializationException( 295 "Failed to get the table name from the Peer object", e); 296 } 297 298 if (userObject == null || userObjectName == null) 299 { 300 throw new InitializationException( 301 "Failed to get the object type from the Peer object", e); 302 } 303 304 305 if (nameColumn == null || namePropDesc == null) 306 { 307 throw new InitializationException( 308 "UserPeer " + userPeerClassName 309 + " has no name column information!", e); 310 } 311 if (idColumn == null || idPropDesc == null) 312 { 313 throw new InitializationException( 314 "UserPeer " + userPeerClassName 315 + " has no id column information!", e); 316 } 317 if (passwordColumn == null || passwordPropDesc == null) 318 { 319 throw new InitializationException( 320 "UserPeer " + userPeerClassName 321 + " has no password column information!", e); 322 } 323 if (firstNameColumn == null || firstNamePropDesc == null) 324 { 325 throw new InitializationException( 326 "UserPeer " + userPeerClassName 327 + " has no firstName column information!", e); 328 } 329 if (lastNameColumn == null || lastNamePropDesc == null) 330 { 331 throw new InitializationException( 332 "UserPeer " + userPeerClassName 333 + " has no lastName column information!", e); 334 } 335 if (emailColumn == null || emailPropDesc == null) 336 { 337 throw new InitializationException( 338 "UserPeer " + userPeerClassName 339 + " has no email column information!", e); 340 } 341 if (confirmColumn == null || confirmPropDesc == null) 342 { 343 throw new InitializationException( 344 "UserPeer " + userPeerClassName 345 + " has no confirm column information!", e); 346 } 347 if (createDateColumn == null || createDatePropDesc == null) 348 { 349 throw new InitializationException( 350 "UserPeer " + userPeerClassName 351 + " has no createDate column information!", e); 352 } 353 if (lastLoginColumn == null || lastLoginPropDesc == null) 354 { 355 throw new InitializationException( 356 "UserPeer " + userPeerClassName 357 + " has no lastLogin column information!", e); 358 } 359 if (objectdataColumn == null || objectdataPropDesc == null) 360 { 361 throw new InitializationException( 362 "UserPeer " + userPeerClassName 363 + " has no objectdata column information!", e); 364 } 365 } 366 } 367 368 /** 369 * Get the name of this table. 370 * 371 * @return A String with the name of the table. 372 */ 373 public static String getTableName() 374 { 375 return tableName; 376 } 377 378 /** 379 * Returns the fully qualified name of the Column to 380 * use as the Name Column for a group 381 * 382 * @return A String containing the column name 383 */ 384 public static String getNameColumn() 385 { 386 return nameColumn; 387 } 388 389 /** 390 * Returns the fully qualified name of the Column to 391 * use as the Id Column for a group 392 * 393 * @return A String containing the column id 394 */ 395 public static String getIdColumn() 396 { 397 return idColumn; 398 } 399 400 /** 401 * Returns the fully qualified name of the Column to 402 * use as the Password Column for a role 403 * 404 * @return A String containing the column name 405 */ 406 public static String getPasswordColumn() 407 { 408 return passwordColumn; 409 } 410 411 /** 412 * Returns the fully qualified name of the Column to 413 * use as the FirstName Column for a role 414 * 415 * @return A String containing the column name 416 */ 417 public static String getFirstNameColumn() 418 { 419 return firstNameColumn; 420 } 421 422 /** 423 * Returns the fully qualified name of the Column to 424 * use as the LastName Column for a role 425 * 426 * @return A String containing the column name 427 */ 428 public static String getLastNameColumn() 429 { 430 return lastNameColumn; 431 } 432 433 /** 434 * Returns the fully qualified name of the Column to 435 * use as the Email Column for a role 436 * 437 * @return A String containing the column name 438 */ 439 public static String getEmailColumn() 440 { 441 return emailColumn; 442 } 443 444 /** 445 * Returns the fully qualified name of the Column to 446 * use as the Confirm Column for a role 447 * 448 * @return A String containing the column name 449 */ 450 public static String getConfirmColumn() 451 { 452 return confirmColumn; 453 } 454 455 /** 456 * Returns the fully qualified name of the Column to 457 * use as the CreateDate Column for a role 458 * 459 * @return A String containing the column name 460 */ 461 public static String getCreateDateColumn() 462 { 463 return createDateColumn; 464 } 465 466 /** 467 * Returns the fully qualified name of the Column to 468 * use as the LastLogin Column for a role 469 * 470 * @return A String containing the column name 471 */ 472 public static String getLastLoginColumn() 473 { 474 return lastLoginColumn; 475 } 476 477 /** 478 * Returns the fully qualified name of the Column to 479 * use as the objectdata Column for a role 480 * 481 * @return A String containing the column name 482 */ 483 public static String getObjectdataColumn() 484 { 485 return objectdataColumn; 486 } 487 488 /** 489 * Returns the full name of a column. 490 * 491 * @param name The column to fully qualify 492 * 493 * @return A String with the full name of the column. 494 */ 495 public static String getColumnName(String name) 496 { 497 StringBuffer sb = new StringBuffer(); 498 sb.append(getTableName()); 499 sb.append("."); 500 sb.append(name); 501 return sb.toString(); 502 } 503 504 /** 505 * Returns the full name of a column. 506 * 507 * @param name The column to fully qualify 508 * 509 * @return A String with the full name of the column. 510 * @deprecated use getColumnName(String name) 511 */ 512 public String getFullColumnName(String name) 513 { 514 return getColumnName(name); 515 } 516 517 518 /** 519 * Returns a new, empty object for the underlying peer. 520 * Used to create a new underlying object 521 * 522 * @return A new object which is compatible to the Peer 523 * and can be used as a User object 524 * 525 */ 526 527 public static Persistent newPersistentInstance() 528 { 529 Persistent obj = null; 530 531 if (userObject == null) 532 { 533 // This can happen if the Turbine wants to determine the 534 // name of the anonymous user before the security service 535 // has been initialized. In this case, the Peer Manager 536 // has not yet been inited and the userObject is still 537 // null. Return null in this case. 538 // 539 return obj; 540 } 541 542 try 543 { 544 obj = (Persistent) userObject.newInstance(); 545 } 546 catch (Exception e) 547 { 548 log.error("Could not instantiate a user object", e); 549 obj = null; 550 } 551 return obj; 552 } 553 554 /** 555 * Checks if a User is defined in the system. The name 556 * is used as query criteria. 557 * 558 * @param user The User to be checked. 559 * @return <code>true</code> if given User exists in the system. 560 * @throws DataBackendException when more than one User with 561 * the same name exists. 562 * @throws Exception A generic exception. 563 */ 564 public static boolean checkExists(User user) 565 throws DataBackendException, Exception 566 { 567 Criteria criteria = new Criteria(); 568 569 criteria.addSelectColumn(getIdColumn()); 570 571 criteria.add(getNameColumn(), user.getName()); 572 573 List results = BasePeer.doSelect(criteria); 574 575 if (results.size() > 1) 576 { 577 throw new DataBackendException("Multiple users named '" + 578 user.getName() + "' exist!"); 579 } 580 return (results.size() == 1); 581 } 582 583 /** 584 * Returns a List of all User objects. 585 * 586 * @return A List with all users in the system. 587 * @exception Exception A generic exception. 588 */ 589 public static List selectAllUsers() 590 throws Exception 591 { 592 Criteria criteria = new Criteria(); 593 criteria.addAscendingOrderByColumn(getLastNameColumn()); 594 criteria.addAscendingOrderByColumn(getFirstNameColumn()); 595 criteria.setIgnoreCase(true); 596 return doSelect(criteria); 597 } 598 599 /** 600 * Returns a List of all confirmed User objects. 601 * 602 * @return A List with all confirmed users in the system. 603 * @exception Exception A generic exception. 604 */ 605 public static List selectAllConfirmedUsers() 606 throws Exception 607 { 608 Criteria criteria = new Criteria(); 609 610 criteria.add (getConfirmColumn(), User.CONFIRM_DATA); 611 criteria.addAscendingOrderByColumn(getLastNameColumn()); 612 criteria.addAscendingOrderByColumn(getFirstNameColumn()); 613 criteria.setIgnoreCase(true); 614 return doSelect(criteria); 615 } 616 617 /* 618 * ======================================================================== 619 * 620 * WARNING! Do not read on if you have a weak stomach. What follows here 621 * are some abominations thanks to the braindead static peers of Torque 622 * and the rigidity of Java.... 623 * 624 * ======================================================================== 625 * 626 */ 627 628 /** 629 * Calls buildCriteria(User user) in the configured UserPeer. If you get 630 * a ClassCastException in this routine, you put a User object into this 631 * method which can't be cast into an object for the TorqueSecurityService. This is a 632 * configuration error most of the time. 633 * 634 * @param user An object which implements the User interface 635 * 636 * @return A criteria for the supplied user object 637 */ 638 639 public static Criteria buildCriteria(User user) 640 { 641 Criteria crit; 642 643 try 644 { 645 Class[] clazz = new Class[] { userObject }; 646 Object[] params = 647 new Object[] { ((TorqueUser) user).getPersistentObj() }; 648 649 crit = (Criteria) userPeerClass 650 .getMethod("buildCriteria", clazz) 651 .invoke(null, params); 652 } 653 catch (Exception e) 654 { 655 crit = null; 656 } 657 658 return crit; 659 } 660 661 /** 662 * Invokes doUpdate(Criteria c) on the configured Peer Object 663 * 664 * @param criteria A Criteria Object 665 * 666 * @exception TorqueException A problem occured. 667 */ 668 669 public static void doUpdate(Criteria criteria) 670 throws TorqueException 671 { 672 try 673 { 674 Class[] clazz = new Class[] { Criteria.class }; 675 Object[] params = new Object[] { criteria }; 676 677 userPeerClass 678 .getMethod("doUpdate", clazz) 679 .invoke(null, params); 680 } 681 catch (Exception e) 682 { 683 throw new TorqueException("doUpdate failed", e); 684 } 685 } 686 687 /** 688 * Invokes doInsert(Criteria c) on the configured Peer Object 689 * 690 * @param criteria A Criteria Object 691 * 692 * @exception TorqueException A problem occured. 693 */ 694 695 public static void doInsert(Criteria criteria) 696 throws TorqueException 697 { 698 try 699 { 700 Class[] clazz = new Class[] { Criteria.class }; 701 Object[] params = new Object[] { criteria }; 702 703 userPeerClass 704 .getMethod("doInsert", clazz) 705 .invoke(null, params); 706 } 707 catch (Exception e) 708 { 709 throw new TorqueException("doInsert failed", e); 710 } 711 } 712 713 /** 714 * Invokes doSelect(Criteria c) on the configured Peer Object 715 * 716 * @param criteria A Criteria Object 717 * 718 * @return A List of User Objects selected by the Criteria 719 * 720 * @exception TorqueException A problem occured. 721 */ 722 public static List doSelect(Criteria criteria) 723 throws TorqueException 724 { 725 List list; 726 727 try 728 { 729 Class[] clazz = 730 new Class[] { Criteria.class }; 731 Object[] params = new Object[] { criteria }; 732 733 list = (List) userPeerClass 734 .getMethod("doSelect", clazz) 735 .invoke(null, params); 736 } 737 catch (Exception e) 738 { 739 throw new TorqueException("doSelect failed", e); 740 } 741 List newList = new ArrayList(list.size()); 742 743 // 744 // Wrap the returned Objects into TorqueUsers. 745 // 746 for (Iterator it = list.iterator(); it.hasNext(); ) 747 { 748 User u = getNewUser((Persistent) it.next()); 749 newList.add(u); 750 } 751 752 return newList; 753 } 754 755 /** 756 * Invokes doDelete(Criteria c) on the configured Peer Object 757 * 758 * @param criteria A Criteria Object 759 * 760 * @exception TorqueException A problem occured. 761 */ 762 public static void doDelete(Criteria criteria) 763 throws TorqueException 764 { 765 try 766 { 767 Class[] clazz = new Class[] { Criteria.class }; 768 Object[] params = new Object[] { criteria }; 769 770 userPeerClass 771 .getMethod("doDelete", clazz) 772 .invoke(null, params); 773 } 774 catch (Exception e) 775 { 776 throw new TorqueException("doDelete failed", e); 777 } 778 } 779 780 /** 781 * Invokes setName(String s) on the supplied base object 782 * 783 * @param obj The object to use for setting the name 784 * @param name The Name to set 785 */ 786 public static void setUserName(Persistent obj, String name) 787 { 788 if (obj == null) 789 { 790 return; 791 } 792 793 try 794 { 795 Object[] params = new Object[] { name }; 796 namePropDesc.getWriteMethod().invoke(obj, params); 797 } 798 catch (ClassCastException cce) 799 { 800 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 801 log.error(msg); 802 throw new RuntimeException(msg); 803 } 804 catch (Exception e) 805 { 806 log.error(e, e); 807 } 808 } 809 810 /** 811 * Invokes getName() on the supplied base object 812 * 813 * @param obj The object to use for getting the name 814 * 815 * @return A string containing the name 816 * 817 * @deprecated use getName(obj) 818 */ 819 public static String getUserName(Persistent obj) 820 { 821 return getName(obj); 822 } 823 824 /** 825 * Invokes getName() on the supplied base object 826 * 827 * @param obj The object to use for getting the name 828 * 829 * @return A string containing the name 830 */ 831 public static String getName(Persistent obj) 832 { 833 String name = null; 834 835 if (obj == null) 836 { 837 return null; 838 } 839 840 try 841 { 842 name = (String) namePropDesc 843 .getReadMethod() 844 .invoke(obj, new Object[] {}); 845 } 846 catch (ClassCastException cce) 847 { 848 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 849 log.error(msg); 850 throw new RuntimeException(msg); 851 } 852 catch (Exception e) 853 { 854 log.error(e, e); 855 } 856 return name; 857 } 858 859 /** 860 * Invokes setPassword(String s) on the supplied base object 861 * 862 * @param obj The object to use for setting the password 863 * @param password The Password to set 864 */ 865 public static void setUserPassword(Persistent obj, String password) 866 { 867 if (obj == null) 868 { 869 return; 870 } 871 872 try 873 { 874 Object[] params = new Object[] { password }; 875 passwordPropDesc.getWriteMethod().invoke(obj, params); 876 } 877 catch (ClassCastException cce) 878 { 879 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 880 log.error(msg); 881 throw new RuntimeException(msg); 882 } 883 catch (Exception e) 884 { 885 log.error(e, e); 886 } 887 } 888 889 /** 890 * Invokes getPassword() on the supplied base object 891 * 892 * @param obj The object to use for getting the password 893 * 894 * @return A string containing the password 895 */ 896 public static String getUserPassword(Persistent obj) 897 { 898 String password = null; 899 900 if (obj == null) 901 { 902 return null; 903 } 904 905 try 906 { 907 password = (String) passwordPropDesc 908 .getReadMethod() 909 .invoke(obj, new Object[] {}); 910 } 911 catch (ClassCastException cce) 912 { 913 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 914 log.error(msg); 915 throw new RuntimeException(msg); 916 } 917 catch (Exception e) 918 { 919 log.error(e, e); 920 } 921 return password; 922 } 923 924 /** 925 * Invokes setFirstName(String s) on the supplied base object 926 * 927 * @param obj The object to use for setting the first name 928 * @param firstName The first name to set 929 */ 930 public static void setUserFirstName(Persistent obj, String firstName) 931 { 932 if (obj == null) 933 { 934 return; 935 } 936 937 try 938 { 939 Object[] params = new Object[] { firstName }; 940 firstNamePropDesc.getWriteMethod().invoke(obj, params); 941 } 942 catch (ClassCastException cce) 943 { 944 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 945 log.error(msg); 946 throw new RuntimeException(msg); 947 } 948 catch (Exception e) 949 { 950 log.error(e, e); 951 } 952 } 953 954 /** 955 * Invokes getFirstName() on the supplied base object 956 * 957 * @param obj The object to use for getting the first name 958 * 959 * @return A string containing the first name 960 */ 961 public static String getUserFirstName(Persistent obj) 962 { 963 String firstName = null; 964 965 if (obj == null) 966 { 967 return null; 968 } 969 970 try 971 { 972 firstName = (String) firstNamePropDesc 973 .getReadMethod() 974 .invoke(obj, new Object[] {}); 975 } 976 catch (ClassCastException cce) 977 { 978 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 979 log.error(msg); 980 throw new RuntimeException(msg); 981 } 982 catch (Exception e) 983 { 984 log.error(e, e); 985 } 986 return firstName; 987 } 988 989 /** 990 * Invokes setLastName(String s) on the supplied base object 991 * 992 * @param obj The object to use for setting the last name 993 * @param lastName The Last Name to set 994 */ 995 public static void setUserLastName(Persistent obj, String lastName) 996 { 997 if (obj == null) 998 { 999 return; 1000 } 1001 1002 try 1003 { 1004 Object[] params = new Object[] { lastName }; 1005 lastNamePropDesc.getWriteMethod().invoke(obj, params); 1006 } 1007 catch (ClassCastException cce) 1008 { 1009 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1010 log.error(msg); 1011 throw new RuntimeException(msg); 1012 } 1013 catch (Exception e) 1014 { 1015 log.error(e, e); 1016 } 1017 } 1018 1019 /** 1020 * Invokes getLastName() on the supplied base object 1021 * 1022 * @param obj The object to use for getting the last name 1023 * 1024 * @return A string containing the last name 1025 */ 1026 public static String getUserLastName(Persistent obj) 1027 { 1028 String lastName = null; 1029 1030 if (obj == null) 1031 { 1032 return null; 1033 } 1034 1035 try 1036 { 1037 lastName = (String) lastNamePropDesc 1038 .getReadMethod() 1039 .invoke(obj, new Object[] {}); 1040 } 1041 catch (ClassCastException cce) 1042 { 1043 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1044 log.error(msg); 1045 throw new RuntimeException(msg); 1046 } 1047 catch (Exception e) 1048 { 1049 log.error(e, e); 1050 } 1051 return lastName; 1052 } 1053 1054 /** 1055 * Invokes setEmail(String s) on the supplied base object 1056 * 1057 * @param obj The object to use for setting the email 1058 * @param email The Email to set 1059 */ 1060 public static void setUserEmail(Persistent obj, String email) 1061 { 1062 if (obj == null) 1063 { 1064 return; 1065 } 1066 1067 try 1068 { 1069 Object[] params = new Object[] { email }; 1070 emailPropDesc.getWriteMethod().invoke(obj, params); 1071 } 1072 catch (ClassCastException cce) 1073 { 1074 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1075 log.error(msg); 1076 throw new RuntimeException(msg); 1077 } 1078 catch (Exception e) 1079 { 1080 log.error(e, e); 1081 } 1082 } 1083 1084 /** 1085 * Invokes getEmail() on the supplied base object 1086 * 1087 * @param obj The object to use for getting the email 1088 * 1089 * @return A string containing the email 1090 */ 1091 public static String getUserEmail(Persistent obj) 1092 { 1093 String email = null; 1094 1095 if (obj == null) 1096 { 1097 return null; 1098 } 1099 1100 try 1101 { 1102 email = (String) emailPropDesc 1103 .getReadMethod() 1104 .invoke(obj, new Object[] {}); 1105 } 1106 catch (ClassCastException cce) 1107 { 1108 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1109 log.error(msg); 1110 throw new RuntimeException(msg); 1111 } 1112 catch (Exception e) 1113 { 1114 log.error(e, e); 1115 } 1116 return email; 1117 } 1118 1119 /** 1120 * Invokes setConfirmed(String s) on the supplied base object 1121 * 1122 * @param obj The object to use for setting the confirm value 1123 * @param confirm The confirm value to set 1124 */ 1125 public static void setUserConfirmed(Persistent obj, String confirm) 1126 { 1127 if (obj == null) 1128 { 1129 return; 1130 } 1131 1132 try 1133 { 1134 Object[] params = new Object[] { confirm }; 1135 confirmPropDesc.getWriteMethod().invoke(obj, params); 1136 } 1137 catch (ClassCastException cce) 1138 { 1139 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1140 log.error(msg); 1141 throw new RuntimeException(msg); 1142 } 1143 catch (Exception e) 1144 { 1145 log.error(e, e); 1146 } 1147 } 1148 1149 /** 1150 * Invokes getConfirmed() on the supplied base object 1151 * 1152 * @param obj The object to use for getting the confirm value 1153 * 1154 * @return A string containing the confirm value 1155 */ 1156 public static String getUserConfirmed(Persistent obj) 1157 { 1158 String confirm = null; 1159 1160 if (obj == null) 1161 { 1162 return null; 1163 } 1164 1165 try 1166 { 1167 confirm = (String) confirmPropDesc 1168 .getReadMethod() 1169 .invoke(obj, new Object[] {}); 1170 } 1171 catch (ClassCastException cce) 1172 { 1173 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1174 log.error(msg); 1175 throw new RuntimeException(msg); 1176 } 1177 catch (Exception e) 1178 { 1179 log.error(e, e); 1180 } 1181 return confirm; 1182 } 1183 1184 /** 1185 * Invokes setCreateDate(java.util.Date date) on the supplied base object 1186 * 1187 * @param obj The object to use for setting the create date 1188 * @param createDate The create date to set 1189 */ 1190 public static void setUserCreateDate(Persistent obj, java.util.Date createDate) 1191 { 1192 if (obj == null) 1193 { 1194 return; 1195 } 1196 1197 try 1198 { 1199 Object[] params = new Object[] { createDate }; 1200 createDatePropDesc.getWriteMethod().invoke(obj, params); 1201 } 1202 catch (ClassCastException cce) 1203 { 1204 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1205 log.error(msg); 1206 throw new RuntimeException(msg); 1207 } 1208 catch (Exception e) 1209 { 1210 log.error(e, e); 1211 } 1212 } 1213 1214 /** 1215 * Invokes getCreateDate() on the supplied base object 1216 * 1217 * @param obj The object to use for getting the create date 1218 * 1219 * @return A string containing the create date 1220 */ 1221 public static java.util.Date getUserCreateDate(Persistent obj) 1222 { 1223 java.util.Date createDate = null; 1224 1225 if (obj == null) 1226 { 1227 return null; 1228 } 1229 1230 try 1231 { 1232 createDate = (java.util.Date) createDatePropDesc 1233 .getReadMethod() 1234 .invoke(obj, new Object[] {}); 1235 } 1236 catch (ClassCastException cce) 1237 { 1238 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1239 log.error(msg); 1240 throw new RuntimeException(msg); 1241 } 1242 catch (Exception e) 1243 { 1244 log.error(e, e); 1245 } 1246 return createDate; 1247 } 1248 1249 /** 1250 * Invokes setLastLogin(java.util.Date date) on the supplied base object 1251 * 1252 * @param obj The object to use for setting the last login daet 1253 * @param lastLogin The last login date to set 1254 */ 1255 public static void setUserLastLogin(Persistent obj, java.util.Date lastLogin) 1256 { 1257 if (obj == null) 1258 { 1259 return; 1260 } 1261 1262 try 1263 { 1264 Object[] params = new Object[] { lastLogin }; 1265 lastLoginPropDesc.getWriteMethod().invoke(obj, params); 1266 } 1267 catch (ClassCastException cce) 1268 { 1269 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1270 log.error(msg); 1271 throw new RuntimeException(msg); 1272 } 1273 catch (Exception e) 1274 { 1275 log.error(e, e); 1276 } 1277 } 1278 1279 /** 1280 * Invokes getLastLogin() on the supplied base object 1281 * 1282 * @param obj The object to use for getting the last login date 1283 * 1284 * @return A string containing the last login date 1285 */ 1286 public static java.util.Date getUserLastLogin(Persistent obj) 1287 { 1288 java.util.Date lastLogin = null; 1289 1290 if (obj == null) 1291 { 1292 return null; 1293 } 1294 1295 try 1296 { 1297 lastLogin = (java.util.Date) lastLoginPropDesc 1298 .getReadMethod() 1299 .invoke(obj, new Object[] {}); 1300 } 1301 catch (ClassCastException cce) 1302 { 1303 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1304 log.error(msg); 1305 throw new RuntimeException(msg); 1306 } 1307 catch (Exception e) 1308 { 1309 log.error(e, e); 1310 } 1311 return lastLogin; 1312 } 1313 1314 /** 1315 * Invokes setObjectdata(byte [] date) on the supplied base object 1316 * 1317 * @param obj The object to use for setting the last login daet 1318 * @param objectdata The objectdata to use 1319 */ 1320 public static void setUserObjectdata(Persistent obj, byte [] objectdata) 1321 { 1322 if (obj == null) 1323 { 1324 return; 1325 } 1326 1327 try 1328 { 1329 Object[] params = new Object[] { objectdata }; 1330 objectdataPropDesc.getWriteMethod().invoke(obj, params); 1331 } 1332 catch (ClassCastException cce) 1333 { 1334 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1335 log.error(msg); 1336 throw new RuntimeException(msg); 1337 } 1338 catch (Exception e) 1339 { 1340 log.error(e, e); 1341 } 1342 } 1343 1344 /** 1345 * Invokes getObjectdata() on the supplied base object 1346 * 1347 * @param obj The object to use for getting the last login date 1348 * 1349 * @return A string containing the last login date 1350 */ 1351 public static byte [] getUserObjectdata(Persistent obj) 1352 { 1353 byte [] objectdata = null; 1354 1355 if (obj == null) 1356 { 1357 return null; 1358 } 1359 1360 try 1361 { 1362 objectdata = (byte []) objectdataPropDesc 1363 .getReadMethod() 1364 .invoke(obj, new Object[] {}); 1365 } 1366 catch (ClassCastException cce) 1367 { 1368 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1369 log.error(msg); 1370 throw new RuntimeException(msg); 1371 } 1372 catch (Exception e) 1373 { 1374 log.error(e, e); 1375 } 1376 return objectdata; 1377 } 1378 1379 /** 1380 * Invokes setId(int n) on the supplied base object 1381 * 1382 * @param obj The object to use for setting the name 1383 * @param id The new Id 1384 */ 1385 public static void setId(Persistent obj, int id) 1386 { 1387 if (obj == null) 1388 { 1389 return; 1390 } 1391 1392 try 1393 { 1394 Object[] params = new Object[] { Integer.TYPE }; 1395 idPropDesc.getWriteMethod().invoke(obj, params); 1396 } 1397 catch (ClassCastException cce) 1398 { 1399 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1400 log.error(msg); 1401 throw new RuntimeException(msg); 1402 } 1403 catch (Exception e) 1404 { 1405 log.error(e, e); 1406 } 1407 } 1408 1409 /** 1410 * Invokes getId() on the supplied base object 1411 * 1412 * @param obj The object to use for getting the id 1413 * 1414 * @return The Id of this object 1415 */ 1416 public static Integer getIdAsObj(Persistent obj) 1417 { 1418 Integer id = null; 1419 1420 if (obj == null) 1421 { 1422 return new Integer(0); 1423 } 1424 1425 try 1426 { 1427 id = (Integer) idPropDesc 1428 .getReadMethod() 1429 .invoke(obj, new Object[] {}); 1430 } 1431 catch (ClassCastException cce) 1432 { 1433 String msg = obj.getClass().getName() + " does not seem to be an User Object!"; 1434 log.error(msg); 1435 throw new RuntimeException(msg); 1436 } 1437 catch (Exception e) 1438 { 1439 log.error(e, e); 1440 } 1441 return id; 1442 } 1443 1444 /** 1445 * Returns the Class of the configured Object class 1446 * from the peer 1447 * 1448 * @return The class of the objects returned by the configured peer 1449 * 1450 */ 1451 1452 private static Class getPersistenceClass() 1453 { 1454 Class persistenceClass = null; 1455 1456 try 1457 { 1458 Object[] params = new Object[0]; 1459 1460 persistenceClass = (Class) userPeerClass 1461 .getMethod("getOMClass", (Class[])null) 1462 .invoke(null, params); 1463 } 1464 catch (Exception e) 1465 { 1466 persistenceClass = null; 1467 } 1468 1469 return persistenceClass; 1470 } 1471 1472 /** 1473 * Returns a new, configured User Object with 1474 * a supplied Persistent object at its core 1475 * 1476 * @param p The persistent object 1477 * 1478 * @return a new, configured User Object 1479 * 1480 * @exception Exception Could not create a new Object 1481 * 1482 */ 1483 1484 public static User getNewUser(Persistent p) 1485 { 1486 User u = null; 1487 try 1488 { 1489 Class userWrapperClass = TurbineSecurity.getUserClass(); 1490 1491 Class [] clazz = new Class [] { Persistent.class }; 1492 Object [] params = new Object [] { p }; 1493 1494 u = (User) userWrapperClass 1495 .getConstructor(clazz) 1496 .newInstance(params); 1497 } 1498 catch (Exception e) 1499 { 1500 log.error("Could not instantiate a new user from supplied persistent: ", e); 1501 } 1502 1503 return u; 1504 } 1505 } 1506 1507