AddressBookBean


1   /*
2    * Copyright (c) 2001 - 2005 ivata limited.
3    * All rights reserved.
4    * -----------------------------------------------------------------------------
5    * ivata groupware may be redistributed under the GNU General Public
6    * License as published by the Free Software Foundation;
7    * version 2 of the License.
8    *
9    * These programs are free software; you can redistribute them and/or
10   * modify them under the terms of the GNU General Public License
11   * as published by the Free Software Foundation; version 2 of the License.
12   *
13   * These programs are distributed in the hope that they will be useful,
14   * but WITHOUT ANY WARRANTY; without even the implied warranty of
15   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16   *
17   * See the GNU General Public License in the file LICENSE.txt for more
18   * details.
19   *
20   * If you would like a copy of the GNU General Public License write to
21   *
22   * Free Software Foundation, Inc.
23   * 59 Temple Place - Suite 330
24   * Boston, MA 02111-1307, USA.
25   *
26   *
27   * To arrange commercial support and licensing, contact ivata at
28   *                  http://www.ivata.com/contact.jsp
29   * -----------------------------------------------------------------------------
30   * $Log: AddressBookBean.java,v $
31   * Revision 1.4  2005/04/29 02:48:14  colinmacleod
32   * Data bugfixes.
33   * Changed primary key back to Integer.
34   *
35   * Revision 1.3  2005/04/10 20:09:34  colinmacleod
36   * Added new themes.
37   * Changed id type to String.
38   * Changed i tag to em and b tag to strong.
39   * Improved PicoContainerFactory with NanoContainer scripts.
40   *
41   * Revision 1.2  2005/04/09 17:19:06  colinmacleod
42   * Changed copyright text to GPL v2 explicitly.
43   *
44   * Revision 1.1.1.1  2005/03/10 17:50:19  colinmacleod
45   * Restructured ivata op around Hibernate/PicoContainer.
46   * Renamed ivata groupware.
47   *
48   * Revision 1.10  2004/11/12 18:17:10  colinmacleod
49   * Ordered imports.
50   *
51   * Revision 1.9  2004/11/12 15:56:47  colinmacleod
52   * Removed dependencies on SSLEXT.
53   * Moved Persistence classes to ivata masks.
54   *
55   * Revision 1.8  2004/11/03 15:36:48  colinmacleod
56   * Changed relationship between person and address:
57   * each person for now has exactly one address.
58   *
59   * Revision 1.7  2004/07/18 21:59:12  colinmacleod
60   * Removed Person from User - now you need to use addressbook/persistence manager to find the person (makes the app run faster.)
61   *
62   * Revision 1.6  2004/07/13 19:41:13  colinmacleod
63   * Moved project to POJOs from EJBs.
64   * Applied PicoContainer to services layer (replacing session EJBs).
65   * Applied Hibernate to persistence layer (replacing entity EJBs).
66   *
67   * Revision 1.5  2004/03/27 10:29:41  colinmacleod
68   * Added getAddressBook implementation.
69   *
70   * Revision 1.4  2004/03/26 21:34:35  colinmacleod
71   * Split off functionality into POJO.
72   *
73   * Revision 1.3  2004/03/21 21:16:05  colinmacleod
74   * Shortened name to ivata op.
75   *
76   * Revision 1.2  2004/02/01 22:00:32  colinmacleod
77   * Added full names to author tags
78   *
79   * Revision 1.1.1.1  2004/01/27 20:57:49  colinmacleod
80   * Moved ivata openportal to SourceForge..
81   *
82   * Revision 1.6  2003/12/12 11:08:58  jano
83   * fixing aaddressbook functionaality
84   *
85   * Revision 1.5  2003/11/03 11:28:24  jano
86   * commiting addressbook,
87   * tryinjg to fix deploying problem
88   *
89   * Revision 1.4  2003/10/17 12:36:12  jano
90   * fixing problems with building
91   * converting intranet -> portal
92   * Eclipse building
93   *
94   * Revision 1.3  2003/10/15 13:36:47  jano
95   * converting to XDoclet
96   *
97   * Revision 1.2  2003/10/15 13:18:02  colin
98   * fixing for XDoclet
99   *
100  * Revision 1.20  2003/08/21 09:49:22  jano
101  * removed unusing methods
102  *
103  * Revision 1.19  2003/08/20 16:23:59  jano
104  * fixing addressBook extension
105  *
106  * Revision 1.18  2003/08/19 14:53:30  jano
107  * *** empty log message ***
108  *
109  * Revision 1.17  2003/08/14 15:54:19  jano
110  * fixing bugs
111  *
112  * Revision 1.16  2003/08/14 08:19:59  jano
113  * fixing bug
114  *
115  * Revision 1.15  2003/08/13 13:32:16  jano
116  * addressBook exttension: next level
117  *
118  * Revision 1.14  2003/08/05 14:51:03  jano
119  * addressBook extension
120  *
121  * Revision 1.13  2003/08/05 05:54:06  jano
122  * new methods in addressbook
123  *
124  * Revision 1.12  2003/07/31 08:45:57  jano
125  * new method findAllPeople
126  * removing all similar methods
127  *
128  * Revision 1.10  2003/07/25 11:40:17  jano
129  * adding functionality for addressBook extension
130  *
131  * Revision 1.9  2003/06/18 14:20:43  jano
132  * fixing problem with removing user
133  *
134  * Revision 1.8  2003/05/23 13:04:46  peter
135  * uncommented email address validation
136  *
137  * Revision 1.7  2003/05/12 13:45:52  colin
138  * added new methods for finding rights
139  *
140  * Revision 1.6  2003/05/02 15:14:57  peter
141  * added email address validation
142  *
143  * Revision 1.5  2003/04/09 08:51:48  jano
144  * handling data of removing user
145  *
146  * Revision 1.4  2003/04/02 09:04:05  jano
147  * again, fixing bug with wrong keys in validate method
148  *
149  * Revision 1.3  2003/03/31 15:44:04  jano
150  * mistake in validate method, using wrong key of applicationResources
151  *
152  * Revision 1.2  2003/02/27 12:57:40  peter
153  * fixed the resouceBundle paths in validation methods
154  *
155  * Revision 1.1  2003/02/24 19:09:20  colin
156  * moved to business
157  *
158  * Revision 1.28  2003/02/21 09:23:17  colin
159  * fixed bug when fileAs values are the same (only 1 was shown)
160  *
161  * Revision 1.27  2003/02/20 20:49:53  colin
162  * changed checking of unique fileAs field to ValidaitonException
163  *
164  * Revision 1.26  2003/02/20 20:22:54  colin
165  * improved validation error handling
166  *
167  * Revision 1.25  2003/02/20 14:34:02  colin
168  * addGroupsToPerson no longer adds child groups to the person (just the parent)
169  *
170  * Revision 1.24  2003/02/18 11:11:27  colin
171  * first release of address book with Struts
172  *
173  * Revision 1.23  2003/02/14 07:57:07  colin
174  * changed finder in AddressBookBean so it finds all groups (rather than just parent groups)
175  *
176  * Revision 1.22  2003/02/04 17:43:44  colin
177  * copyright notice
178  *
179  * Revision 1.21  2003/01/30 15:29:38  colin
180  * added group validation
181  *
182  * Revision 1.20  2003/01/10 10:30:06  jano
183  * we need information about user who created group
184  *
185  * Revision 1.19  2003/01/09 13:31:49  jano
186  * we have fiield in Person called : createdBy - its name of user who created that contact
187  *
188  * Revision 1.18  2003/01/09 10:02:51  jano
189  * we are not storing group's rights in geoupDO now
190  * we are using methods in addressBookRightsBean
191  *
192  * Revision 1.17  2003/01/03 15:43:50  jano
193  * we don't need tempFindTarge...... method, we are using getTargetIdsByAUD
194  *
195  * Revision 1.16  2002/12/16 13:41:34  jano
196  * in there is not groupId we have to find only those contacts which we can see
197  *
198  * Revision 1.15  2002/12/12 15:03:28  jano
199  * rights for groups
200  *
201  * Revision 1.14  2002/12/03 15:42:19  jano
202  * if the person is user so put him to USER group if he is not there
203  *
204  * Revision 1.13  2002/10/11 12:51:10  colin
205  * added check for duplicate values of fileAs
206  *
207  * Revision 1.12  2002/09/30 12:51:34  jano
208  * trow exception if the group i main group for any people
209  *
210  * Revision 1.11  2002/09/27 14:18:19  jano
211  * when you want delete group contain sub groups throw exception
212  *
213  * Revision 1.10  2002/09/17 08:36:59  colin
214  * added checkDO to check the person before adding
215  *
216  * Revision 1.9  2002/09/09 08:38:10  colin
217  * moved user handling to new security bean
218  *
219  * Revision 1.8  2002/09/02 08:47:48  colin
220  * added country handling and sorting (comparator)
221  *
222  * Revision 1.7  2002/08/30 09:48:45  colin
223  * added employee EJB
224  *
225  * Revision 1.6  2002/08/29 14:33:43  colin
226  * changed AddressBook: added isUserEnabled method
227  *
228  * Revision 1.5  2002/07/26 13:07:21  colin
229  * split user rights off into separate class
230  * added mail server methods
231  *
232  * Revision 1.4  2002/06/28 13:15:22  colin
233  * first addressbook release
234  *
235  * Revision 1.3  2002/06/17 10:45:47  colin
236  * Tidied up the canUser... code
237  *
238  * Revision 1.2  2002/06/17 07:28:51  colin
239  * improved and extended javadoc documentation
240  * -----------------------------------------------------------------------------
241  */
242 package com.ivata.groupware.business.addressbook;
243 
244 import java.util.List  ;
245 
246 import javax.ejb.CreateException  ;
247 import javax.ejb.RemoveException  ;
248 import javax.ejb.SessionBean  ;
249 import javax.ejb.SessionContext  ;
250 
251 import org.picocontainer.PicoContainer;
252 
253 import com.ivata.groupware.admin.security.server.SecuritySession;
254 import com.ivata.groupware.business.addressbook.address.AddressDO;
255 import com.ivata.groupware.business.addressbook.address.country.CountryDO;
256 import com.ivata.groupware.business.addressbook.person.PersonDO;
257 import com.ivata.groupware.business.addressbook.person.group.GroupDO;
258 import com.ivata.groupware.container.PicoContainerFactory;
259 import com.ivata.mask.util.SystemException;
260 import com.ivata.mask.validation.ValidationErrors;
261 
262 
263 /**
264  * <p>This address book provides clients with access to the register of people
265  * within the ivata groupware system.</p>
266  *
267  * <p>Actions are here to retrieve people, change their details and enter new
268  * people into the system. This bean manages people's street and
269  * telecommunications addresses, together with which people are users and what
270  * group(s) each person is a member of.</p>
271  *
272  * <p>Furthermore, this bean is responsible for assigning and maintaining
273  * employee information.</p>
274  *
275  * <p><strong>Note</strong>, however that whilst the addressbook may react on which
276  * people are users (it checks those people always have an email address), this
277  * <em>EJB</em> is not responsible for adding, removing or amending users or their
278  * passwords. For that functionality, see the {@link com.ivata.groupware.admin.security.SecurityBean
279  * SecurityBean}.</p>
280  *
281  * @since 2002-05-12
282  * @author Colin MacLeod
283  * <a HREF='mailto:colin.macleod@ivata.com'>colin.macleod@ivata.com</a>
284  * @version $Revision: 1.4 $
285  * TODO: the employee and user methods need to check the user rights
286  *
287  * @ejb.bean
288  *      name="AddressBook"
289  *      display-name="AddressBook"
290  *      type="Stateless"
291  *      view-type="remote"
292  *      jndi-name="AddressBookRemote"
293  *
294  * @ejb.transaction
295  *      type = "Required"
296  *
297  *  @ejb.home
298  *      generate="false"
299  *      remote-class="com.ivata.groupware.business.addressbook.AddressBookRemoteHome"
300  *
301  *  @ejb.interface
302  *      remote-class="com.ivata.groupware.business.addressbook.AddressBookRemote"
303  */
304 public class AddressBookBean implements SessionBean  , AddressBook {
305     /**
306      * <p>Provides the session bean with container-specific information.</p>
307      */
308     SessionContext   sessionContext;
309 
310 
311     /**
312      * <p>Add bew AddressBook.</p>
313      * @param userName
314      * @param groupDO
315      * @return
316      *
317      * @ejb.interface-method
318      *      view-type = "remote"
319      */
320     public GroupDO addAddressBook(final SecuritySession securitySession,
321             final GroupDO groupDO)
322             throws SystemException {
323         return getAddressBook().addAddressBook(securitySession, groupDO);
324     }
325 
326     /**
327      * <p>Add a new group to the address book.</p>
328      *
329      * @param userName the name of the user who wants to add the group. This is
330      *     used to check user rights.
331      * @param groupDO a data object containing all the details
332      *     of the group to add.
333      * @exception com.ivata.groupware.ejb.entity.UserRightException if the user
334      *     provided is not entitled to add this group
335      * @exception com.ivata.groupware.ejb.entity.InvalidFieldValueException
336      *     if a field value in the new group contains an invalid value
337      * @return the new group data object, with the details as they
338      *     now are in the adressbook.
339      *
340      * @ejb.interface-method
341      *      view-type = "remote"
342      */
343     public GroupDO addGroup(final SecuritySession securitySession,
344             final GroupDO groupDO)
345             throws SystemException {
346         return getAddressBook().addGroup(securitySession, groupDO);
347     }
348 
349     /**
350      * <p>Add a new person to the address book.</p>
351      *
352      * @param personDO data object containing the details of the
353      *     person you want to add.
354      * @return the new person data object, with the details as they
355      *     now are in the adressbook.
356      *
357      * @ejb.interface-method
358      *      view-type = "remote"
359      */
360     public PersonDO addPerson(final SecuritySession securitySession,
361             final PersonDO personDO)
362             throws SystemException {
363         return getAddressBook().addPerson(securitySession, personDO);
364     }
365 
366     /**
367      * <p>add new userGroup.</p>
368      * @param userName
369      * @param groupDO
370      * @return
371      *
372      * @ejb.interface-method
373      *      view-type = "remote"
374      */
375     public GroupDO addUserGroup(final SecuritySession securitySession,
376             final GroupDO groupDO)
377             throws SystemException {
378         return getAddressBook().addUserGroup(securitySession, groupDO);
379     }
380 
381     /**
382      * <p>Amend the details of a group in the public address book.</p>
383      *
384      * @param userName the name of the user who wants to amend the group. This
385      *     is used to check user rights.
386      * @param groupDO a data object containing all the details
387      *     of the group to amend.
388      * @exception com.ivata.groupware.ejb.entity.UserRightException if the user
389      *     provided is not entitled to amend this group.
390      * @exception com.ivata.groupware.ejb.entity.InvalidFieldValueException
391      *     if a field value in the new group contains an invalid value.
392      * @return the new group data object, with the details as they
393      *     now are in the adressbook.
394      *
395      * @ejb.interface-method
396      *      view-type = "remote"
397      */
398     public GroupDO amendGroup(final SecuritySession securitySession,
399             final GroupDO groupDO)
400             throws SystemException {
401         return getAddressBook().amendGroup(securitySession, groupDO);
402     }
403 
404     /**
405      * <p>Change/update a person's details in the addressbook.</p>
406      *
407      * @param personDO data object containing the details of the
408      *     person you want to amend.
409      * @return the new person data object, with the details as they
410      *     now are in the adressbook.
411      *
412      * @ejb.interface-method
413      *      view-type = "remote"
414      */
415     public PersonDO amendPerson(final SecuritySession securitySession,
416             final PersonDO personDO)
417             throws SystemException {
418         return getAddressBook().amendPerson(securitySession, personDO);
419     }
420 
421     /**
422      * <p>Called by the container to notify an entity object it has been
423      * activated.</p>
424      */
425     public void ejbActivate() {}
426 
427     /**
428      * <p>Called by the container just after the bean has been created.</p>
429      *
430      * @exception CreateException if any error occurs. Never thrown by this
431      *     class.
432      *
433      * @ejb.create-method
434      */
435     public void ejbCreate() throws CreateException   {}
436 
437     /**
438      * <p>Called by the container to notify the entity object it will be
439      * deactivated. Called just before deactivation.</p>
440      */
441     public void ejbPassivate() {}
442 
443     /**
444      * <p>This method is called by the container when the bean is about
445      * to be removed.</p>
446      *
447      * <p>This method will be called after a client calls the <code>remove</code>
448      * method of the remote/local home interface.</p>
449      *
450      * @throws RemoveException if any error occurs. Currently never thrown by
451      *     this class.
452      */
453     public final void ejbRemove() {}
454 
455     /**
456      * <p>get Map of all address book names which are allowed with specific access.</p>
457      * @param userName
458      * @param access
459      * @return
460      *
461      * @ejb.interface-method
462      *      view-type = "remote"
463      */
464     public List   findAddressBooks(final SecuritySession securitySession,
465             final boolean includePersonal)
466             throws SystemException {
467         return getAddressBook().findAddressBooks(securitySession, includePersonal);
468     }
469 
470     /**
471      * <p>Find all of the countries in the system.</p>
472      *
473      * @return all of the coutries in the system as a <code>List</code>
474      * of {@link com.ivata.groupware.business.addressbook.address.country.CountryDO CountryDO}
475      * instances.
476      *
477      * @ejb.interface-method
478      *      view-type = "remote"
479      */
480     public List   findAllCountries(final SecuritySession securitySession)
481             throws SystemException {
482         return getAddressBook().findAllCountries(securitySession);
483     }
484 
485 
486     /**
487      * <p>Find All People in a specific address book.</p
488      *
489      * @see com.ivata.groupware.business.addressbook.AddressBook#findAllPeople(com.ivata.groupware.admin.security.server.SecuritySession, Integer, Integer, String)
490      * @ejb.interface-method
491      *      view-type = "remote"
492      */
493     public List   findAllPeopleInGroup(final SecuritySession securitySession,
494             final GroupDO group,
495             final String   initialLetter) throws SystemException {
496         return getAddressBook().findAllPeopleInGroup(securitySession, group,
497             initialLetter);
498     }
499 
500     /**
501      * <p>Find a single county identified by its two-letter country code.</p>
502      *
503      * @param countryCode two-letter internet country code.
504      * @return details of the country as an instance of
505      * {@link com.ivata.groupware.business.addressbook.address.country.CountryDO CountryDO),
506      * or <code>null</code> if no such country exists.
507      *
508      * @ejb.interface-method
509      *      view-type = "remote"
510      */
511     public CountryDO findCountryByCode(final SecuritySession securitySession,
512             final String   countryCode)
513             throws SystemException {
514         return getAddressBook().findCountryByCode(securitySession, countryCode);
515     }
516 
517     /**
518      * <p>Find a group in the address book by its unique identifier.</p>
519      *
520      * @param id the unique identifier of the group to find.
521      * @return the data object of the group which matches this unique
522      *      identifier.
523      *
524      * @ejb.interface-method
525      *      view-type = "remote"
526      */
527     public GroupDO findGroupByPrimaryKey(final SecuritySession securitySession,
528             final Integer   id)
529             throws SystemException {
530         return getAddressBook().findGroupByPrimaryKey(securitySession, id);
531     }
532 
533     /**
534      * <p>
535      * Find all groups which are siblings, identified by the parent group.
536      * </p>
537      * @see com.ivata.groupware.business.addressbook.AddressBook#findGroupsByParent(com.ivata.groupware.admin.security.server.SecuritySession, Integer)
538      */
539     public List   findGroupsByParent(final SecuritySession securitySession,
540             final Integer   parentId) throws SystemException {
541         return getAddressBook().findGroupsByParent(securitySession, parentId);
542     }
543 
544     /**
545      * <p>Find Id of personal AddressBook.</p>
546      * @param userName
547      * @return
548      *
549      * @ejb.interface-method
550      *      view-type = "remote"
551      */
552     public GroupDO findPersonalAddressBook(final SecuritySession securitySession)
553             throws SystemException {
554         return getAddressBook().findPersonalAddressBook(securitySession);
555     }
556 
557     /**
558      * <p>Find a person in the address book by their unique identifier.</p>
559      *
560      * @param id the unique identifier of the person to find.
561      * @return the person data object which matches this id, with the
562      *      details as they now are in the adressbook.
563      *
564      * @ejb.interface-method
565      *      view-type = "remote"
566      */
567     public PersonDO findPersonByPrimaryKey(final SecuritySession securitySession,
568             final String   id)
569             throws SystemException {
570         return getAddressBook().findPersonByPrimaryKey(securitySession, id);
571     }
572 
573     /**
574      * <p>Find a person in the address book by their user name.</p>
575      *
576      * @param userName Name of the user to find.
577      * @return the person data object which matches this user name.
578      * @see com.ivata.groupware.business.addressbook.AddressBook#findPersonByUserName(com.ivata.groupware.admin.security.server.SecuritySession, String)
579      */
580     public PersonDO findPersonByUserName(final SecuritySession securitySession,
581             final String   userName) throws SystemException {
582         return getAddressBook().findPersonByUserName(securitySession, userName);
583     }
584 
585     /**
586      * <p>get Map of all usergroup names which are allowed with specific access.</p>
587      * @param userName
588      * @param access
589      * @return
590      *
591      * @ejb.interface-method
592      *      view-type = "remote"
593      */
594     public List   findUserGroups(final SecuritySession securitySession,
595             final boolean includeAdministrator)
596             throws SystemException {
597         return getAddressBook().findUserGroups(securitySession, includeAdministrator);
598     }
599 
600     /**
601      * Get the addressbook implementation from the <code>PicoContainer</code>.
602      */
603     private AddressBook getAddressBook()
604             throws SystemException {
605         PicoContainer container = PicoContainerFactory.getInstance()
606             .getGlobalContainer();
607         return (AddressBook) container.getComponentInstance(AddressBook.class);
608     }
609 
610     /**
611      * <p>Remove a group from the public address book.</p>
612      *
613      * @param userName the name of the user who wants to remove the group. This
614      *     is used to check user rights.
615      * @param groupDO a data object containing all the details
616      *     of the group to remove. The id of the group is used to identify which
617      *      group to remove.
618      * @exception com.ivata.groupware.ejb.entity.UserRightException if the user
619      *     provided is not entitled to remvoe this group.
620      * @exception com.ivata.groupware.ejb.entity.InvalidFieldValueException
621      *     if the id of the group contains an invalid value.
622      *
623      * @ejb.interface-method
624      *      view-type = "remote"
625      */
626     public void removeGroup(final SecuritySession securitySession,
627             final Integer   id)
628             throws SystemException {
629         getAddressBook().removeGroup(securitySession, id);
630     }
631 
632     /**
633      * <p>Remove a person from the address book.</p>
634      *
635      * @param personDO data object containing the details of the
636      *     person you want to remove. The id is used to locate and remove the
637      *     person.
638      *
639      * @ejb.interface-method
640      *      view-type = "remote"
641      */
642     public void removePerson(final SecuritySession securitySession,
643             final Integer   id)
644             throws SystemException {
645         getAddressBook().removePerson(securitySession, id);
646     }
647 
648     /**
649      * <p>Set up the context for this entity object. The session bean stores the
650      * context for later use.</p>
651      *
652      * @param sessionContext the new context which the session object should
653      *     store.
654      */
655     public final void setSessionContext(final SessionContext   sessionContext) {
656         this.sessionContext = sessionContext;
657     }
658 
659     /**
660      * <p>Confirm all of the elements of the person are address and valid,
661      * before the message is sent.</p>
662      *
663      * @param addressDO data object to check for consistency and
664      *     completeness.
665      * @return a collection of validation errors if any of the
666      *     mandatory fields are missing, or if fields contain invalid values.
667      *
668      * @ejb.interface-method
669      *      view-type = "remote"
670      */
671     public ValidationErrors validate(final SecuritySession securitySession,
672             final AddressDO addressDO)
673             throws SystemException {
674         return getAddressBook().validate(securitySession, addressDO);
675     }
676 
677     /**
678      * <p>Confirm all of the elements of the group are present and valid,
679      * before the message is sent.</p>
680      *
681      * @param groupDO data object to check for consistency and
682      *     completeness.
683      * @return a collection of validation errors if any of the
684      *     mandatory fields are missing, or if fields contain invalid values.
685      *
686      * @ejb.interface-method
687      *      view-type = "remote"
688      */
689     public ValidationErrors validate(final SecuritySession securitySession,
690             final GroupDO groupDO)
691             throws SystemException {
692         return getAddressBook().validate(securitySession, groupDO);
693     }
694 
695     /**
696      * <p>Confirm all of the elements of the person are present and valid,
697      * before the message is sent.</p>
698      *
699      * @param personDO data object to check for consistency and
700      *     completeness.
701      * @return a collection of validation errors if any of the
702      *     mandatory fields are missing, or if fields contain invalid values.
703      *
704      * @ejb.interface-method
705      *      view-type = "remote"
706      */
707     public ValidationErrors validate(final SecuritySession securitySession,
708             final PersonDO personDO)
709             throws SystemException {
710         return getAddressBook().validate(securitySession, personDO);
711     }
712 
713 }
714
A to Z: JavaDoc & Examples Daily Java News & Articles Open Source Projects Open Source Codes Free Computer Books Remove Frame
Popular Tags