1 package org.apache.turbine.services.security.torque;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.beans.PropertyDescriptor;
23
24 import java.util.ArrayList;
25 import java.util.Iterator;
26 import java.util.List;
27
28 import org.apache.commons.configuration.Configuration;
29
30 import org.apache.commons.logging.Log;
31 import org.apache.commons.logging.LogFactory;
32
33 import org.apache.torque.TorqueException;
34 import org.apache.torque.om.Persistent;
35 import org.apache.torque.util.BasePeer;
36 import org.apache.torque.util.Criteria;
37
38 import org.apache.turbine.om.security.User;
39 import org.apache.turbine.services.InitializationException;
40 import org.apache.turbine.services.security.TurbineSecurity;
41 import org.apache.turbine.util.security.DataBackendException;
42
43 /***
44 * This class capsulates all direct Peer access for the User entities.
45 * It allows the exchange of the default Turbine supplied TurbineUserPeer
46 * class against a custom class.
47 *
48 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
49 * @version $Id: UserPeerManager.java 534527 2007-05-02 16:10:59Z tv $
50 */
51
52 public class UserPeerManager
53 implements UserPeerManagerConstants
54 {
55 /*** Serial UID */
56 private static final long serialVersionUID = 6943046259921811593L;
57
58 /*** The class of the Peer the TorqueSecurityService uses */
59 private static Class userPeerClass = null;
60
61 /*** The class name of the objects returned by the configured peer. */
62 private static Class userObject = null;
63
64 /*** The name of the Table used for Group Object queries */
65 private static String tableName = null;
66
67 /*** The name of the column used as "Name" Column */
68 private static String nameColumn = null;
69
70 /*** The name of the column used as "Id" Column */
71 private static String idColumn = null;
72
73 /*** The name of the column used as "Password" Column */
74 private static String passwordColumn = null;
75
76 /*** The name of the column used as "First name" Column */
77 private static String firstNameColumn = null;
78
79 /*** The name of the column used as "Last name" Column */
80 private static String lastNameColumn = null;
81
82 /*** The name of the column used as "Email" Column */
83 private static String emailColumn = null;
84
85 /*** The name of the column used as "Confirm" Column */
86 private static String confirmColumn = null;
87
88 /*** The name of the column used as "create date" Column */
89 private static String createDateColumn = null;
90
91 /*** The name of the column used as "last login" Column */
92 private static String lastLoginColumn = null;
93
94 /*** The name of the column used as "objectdata" Column */
95 private static String objectdataColumn = null;
96
97 /*** The "Name" property descriptor */
98 private static PropertyDescriptor namePropDesc = null;
99
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
156
157
158
159
160
161 userObject = getPersistenceClass();
162
163 userObjectName = conf.getString(USER_CLASS_KEY,
164 userObject.getName());
165
166
167 userObject = Class.forName(userObjectName);
168
169
170
171
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
534
535
536
537
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
621
622
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
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