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