KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > com > nightlabs > ipanema > security > UserManagerBean


1 /*
2  * Created on 02.03.2004
3  *
4  * Copyright NightLabs GmbH, 2004
5  */

6
7 package com.nightlabs.ipanema.security;
8 import java.rmi.RemoteException JavaDoc;
9 import java.util.Collection JavaDoc;
10 import java.util.HashSet JavaDoc;
11 import java.util.Iterator JavaDoc;
12
13 import javax.ejb.CreateException JavaDoc;
14 import javax.ejb.EJBException JavaDoc;
15 import javax.ejb.SessionBean JavaDoc;
16 import javax.ejb.SessionContext JavaDoc;
17 import javax.jdo.Extent;
18 import javax.jdo.FetchPlan;
19 import javax.jdo.JDODetachedFieldAccessException;
20 import javax.jdo.JDOHelper;
21 import javax.jdo.JDOObjectNotFoundException;
22 import javax.jdo.PersistenceManager;
23 import javax.jdo.Query;
24
25 import org.apache.log4j.Logger;
26
27 import com.nightlabs.ModuleException;
28 import com.nightlabs.ipanema.base.BaseSessionBeanImpl;
29 import com.nightlabs.ipanema.person.Person;
30 import com.nightlabs.ipanema.person.id.PersonID;
31 import com.nightlabs.ipanema.security.id.AuthorityID;
32 import com.nightlabs.ipanema.security.id.RoleGroupID;
33 import com.nightlabs.ipanema.security.id.UserID;
34 import com.nightlabs.ipanema.security.id.UserRefID;
35 import com.nightlabs.jdo.NLJDOHelper;
36 import com.nightlabs.jdo.ObjectIDException;
37
38 /**
39  * @author Alexander Bieber <alex@nightlabs.de>
40  * @author Niklas Schiffler <nick@nightlabs.de>
41  * @author Marco Schulze <marco@nightlabs.de>
42  */

43
44 /**
45  * @ejb.bean name="ipanema/ejb/IpanemaBaseBean/UserManager"
46  * jndi-name="ipanema/ejb/IpanemaBaseBean/UserManager"
47  * type="Stateless"
48  *
49  * @ejb.util generate = "physical"
50  **/

51 public abstract class UserManagerBean
52 extends BaseSessionBeanImpl
53 implements SessionBean JavaDoc
54 {
55   public static final Logger LOGGER = Logger.getLogger(UserManagerBean.class);
56   
57   /**
58    * @see com.nightlabs.ipanema.base.BaseSessionBeanImpl#setSessionContext(javax.ejb.SessionContext)
59    */

60   public void setSessionContext(SessionContext JavaDoc sessionContext)
61   throws EJBException JavaDoc, RemoteException JavaDoc
62   {
63     super.setSessionContext(sessionContext);
64   }
65   /**
66    * @see com.nightlabs.ipanema.base.BaseSessionBeanImpl#unsetSessionContext()
67    */

68   public void unsetSessionContext() {
69     super.unsetSessionContext();
70   }
71   
72   /**
73    * @ejb.create-method
74    * @ejb.permission role-name="_Guest_"
75    * @!!!ejb.permission role-name="UserManager-read"
76    */

77   public void ejbCreate() throws CreateException JavaDoc
78   {
79   }
80
81   /**
82    * @see javax.ejb.SessionBean#ejbRemove()
83    *
84    * @ejb.permission unchecked="true"
85    */

86   public void ejbRemove() throws EJBException JavaDoc, RemoteException JavaDoc { }
87   
88   /**
89    *
90    *
91    * @throws ModuleException
92    *
93    * @deprecated use saveUser instead
94    *
95    * @ejb.interface-method
96    * @ejb.permission role-name="UserManager-write"
97    * @ejb.transaction type = "Required"
98    */

99   public User saveDetachedUser(User user, String JavaDoc [] fetchGroups)
100     throws ModuleException
101   {
102     PersistenceManager pm = this.getPersistenceManager();
103     try
104         {
105         User result = (User)NLJDOHelper.storeJDO(pm, user, true, fetchGroups);
106         return result;
107     }
108     finally
109         {
110         pm.close();
111     }
112   }
113   
114   /**
115    * Create a new user or change an existing one. You can leave user.organisationID <code>null</code>.
116    *
117    * @ejb.interface-method
118    * @ejb.permission role-name="UserManager-write"
119    * @ejb.transaction type = "Required"
120    **/

121   public void saveUser(User user)
122     throws SecurityException JavaDoc
123   {
124     try
125     {
126       if (user.getOrganisationID() != null && !user.getOrganisationID().equals(getOrganisationID()))
127         throw new IllegalArgumentException JavaDoc("user.organisationID must be null or equal to your organisationID!!!");
128
129       if (user.getOrganisationID() == null)
130         user.setOrganisationID(getOrganisationID());
131
132       PersistenceManager pm = this.getPersistenceManager();
133       if (JDOHelper.isDetached(user))
134       {
135         if(user.passwdChanged)
136         {
137           String JavaDoc password = user.getPassword();
138           if(user instanceof UserGroup)
139             throw new IllegalArgumentException JavaDoc("You cannot set a password for a UserGroup! userGroup.password must be null!");
140           if(user.passwdChanged)
141             user.setPassword(User.encryptPassword(user.getPassword()));
142         }
143         pm.attachCopy(user, false);
144       }
145       else
146       {
147         user.setPassword(User.encryptPassword(user.getPassword()));
148         pm.makePersistent(user);
149       }
150       pm.close();
151     }
152     catch (ModuleException e)
153     {
154       throw new SecurityException JavaDoc(e);
155     }
156   }
157     
158   /**
159    * @see User.USERTYPE_ORGANISATION
160    * @see User.USERTYPE_USER
161    *
162    * @ejb.interface-method
163    * @ejb.permission role-name="UserManager-read"
164    **/

165   public UserSearchResult searchUsers (
166       String JavaDoc userType,
167       String JavaDoc searchStr, boolean exact, int itemsPerPage, int pageIndex, int userIncludeMask)
168   throws SecurityException JavaDoc
169   {
170     try {
171       PersistenceManager pm = getPersistenceManager();
172       try {
173         UserSearchResult result = User.searchUsers(
174             pm, userType, searchStr, exact, itemsPerPage, pageIndex, userIncludeMask);
175         
176         result.makeTransient(userIncludeMask);
177         return result;
178       } finally {
179         if (AuthorityManagerBean.CLOSE_PM) pm.close();
180       }
181     } catch (Exception JavaDoc x) {
182       throw new SecurityException JavaDoc(x);
183     }
184   }
185   
186   /**
187    * Calls {@link #getUsersByType(String, String[])} with only the default-fetch-group
188    *
189    * @param userType one of User.USERTYPE*
190    * @return
191    * @throws ModuleException
192    *
193    * @ejb.interface-method
194    * @ejb.permission role-name="UserManager-read"
195    */

196   public Collection JavaDoc getUsersByType(String JavaDoc userType)
197   throws ModuleException
198   {
199     return getUsersByType(userType,null);
200   }
201   
202   /**
203    * @throws ModuleException
204    * @see User.USERTYPE_ORGANISATION
205    * @see User.USERTYPE_USER
206    *
207    * @ejb.interface-method
208    * @ejb.permission role-name="UserManager-read"
209    **/

210   public Collection JavaDoc getUsersByType(String JavaDoc userType, String JavaDoc [] fetchGroups)
211   throws ModuleException
212   {
213     PersistenceManager pm = getPersistenceManager();
214     try
215     {
216       if (fetchGroups != null)
217         pm.getFetchPlan().setGroups(fetchGroups);
218       else
219         pm.getFetchPlan().clearGroups();
220       
221       Query query = pm.newQuery(pm.getExtent(User.class, true));
222       query.declareImports("import java.lang.String");
223       query.declareParameters("String userType, String systemUserID, String otherUserID");
224       query.setFilter("this.userType == userType && this.userID != systemUserID && this.userID != otherUserID");
225       query.setOrdering("this.userID ascending");
226       Collection JavaDoc c = (Collection JavaDoc)query.execute(userType, User.SYSTEM_USERID, User.OTHER_USERID);
227       return pm.detachCopyAll(c);
228     }
229     finally
230     {
231       pm.close();
232     }
233   }
234
235   /**
236    * @throws ModuleException
237    *
238    * @ejb.interface-method
239    * @ejb.permission role-name="UserManager-read"
240    **/

241   public Collection JavaDoc getAllUsers()
242     throws ModuleException
243     {
244     return getAllUsers(null);
245   }
246
247   /**
248    * @throws ModuleException
249    *
250    * @ejb.interface-method
251    * @ejb.permission role-name="UserManager-read"
252    **/

253   public Collection JavaDoc getAllUsers(String JavaDoc [] fetchGroups)
254     throws ModuleException
255   {
256     PersistenceManager pm = getPersistenceManager();
257     try
258     {
259       if (fetchGroups != null)
260         pm.getFetchPlan().setGroups(fetchGroups);
261       else
262         pm.getFetchPlan().clearGroups();
263
264       Query query = pm.newQuery(pm.getExtent(User.class, true));
265       query.declareImports("import java.lang.String");
266       query.declareParameters("String systemUserID");
267       query.setFilter("this.userID != systemUserID");
268       query.setOrdering("this.userID ascending");
269       Collection JavaDoc c = (Collection JavaDoc)query.execute(User.SYSTEM_USERID);
270       return pm.detachCopyAll(c);
271     }
272     finally
273     {
274       pm.close();
275     }
276   }
277
278   /**
279    * @throws ModuleException
280    *
281    * @ejb.interface-method
282    * @ejb.permission role-name="UserManager-read"
283    **/

284   public Collection JavaDoc getUsersInUserGroup(String JavaDoc userGroupID)
285     throws ModuleException
286   {
287     return getUsersInUserGroup(userGroupID, null);
288   }
289     
290   /**
291    * @throws ModuleException
292    *
293    * @ejb.interface-method
294    * @ejb.permission role-name="UserManager-read"
295    **/

296   public Collection JavaDoc getUsersInUserGroup(String JavaDoc userGroupID, String JavaDoc [] fetchGroups)
297     throws ModuleException
298   {
299     PersistenceManager pm = getPersistenceManager();
300     try
301     {
302       if (fetchGroups != null)
303         pm.getFetchPlan().setGroups(fetchGroups);
304       else
305         pm.getFetchPlan().clearGroups();
306
307       UserGroup ug = (UserGroup)pm.getObjectById(UserID.create(getOrganisationID(), userGroupID));
308       return (Collection JavaDoc)pm.detachCopyAll(ug.getUsers());
309     }
310     finally
311     {
312       pm.close();
313     }
314   }
315
316   /**
317    * @throws ModuleException
318    *
319    * @ejb.interface-method
320    * @ejb.permission role-name="UserManager-read"
321    **/

322   public Collection JavaDoc getUsersNotInUserGroup(String JavaDoc userGroupID)
323     throws ModuleException
324   {
325     return getUsersNotInUserGroup(userGroupID, null);
326   }
327   
328   /**
329    * @throws ModuleException
330    *
331    * @ejb.interface-method
332    * @ejb.permission role-name="UserManager-read"
333    **/

334   public Collection JavaDoc getUsersNotInUserGroup(String JavaDoc userGroupID, String JavaDoc [] fetchGroups)
335     throws ModuleException
336   {
337     PersistenceManager pm = getPersistenceManager();
338     try
339     {
340       if (fetchGroups != null)
341         pm.getFetchPlan().setGroups(fetchGroups);
342       else
343         pm.getFetchPlan().clearGroups();
344
345       Extent ext = pm.getExtent(User.class, true);
346
347       // FIXME: JPOX generates "WHERE (1=0)" in SQL statement with this query
348
// Query query = pm.newQuery(
349
// "SELECT FROM com.nightlabs.ipanema.security.User " +
350
// "WHERE " +
351
// " (userType == \"" + User.USERTYPE_USER + "\" || userType == \"" + User.USERTYPE_ORGANISATION + "\") &&" +
352
// " !(userGroup.users.containsValue(this)) &&" +
353
// " userGroup.organisationID == paramOrganisationID &&" +
354
// " userGroup.userID == paramUserGroupID " +
355
// " this.userID != \"" + User.SYSTEM_USERID + "\" && " +
356
// " this.userID != \"" + User.OTHER_USERID + "\" " +
357
// "VARIABLES UserGroup userGroup " +
358
// "PARAMETERS String paramOrganisationID, String paramUserGroupID " +
359
// "IMPORTS import com.nightlabs.ipanema.security.UserGroup; import java.lang.String");
360
// Collection c = (Collection)query.execute(getOrganisationID(), userGroupID);
361
// return (Collection)pm.detachCopyAll(c);
362

363       // workaround start
364
UserGroup ug = (UserGroup)pm.getObjectById(UserID.create(getOrganisationID(), userGroupID));
365
366       Query query = pm.newQuery("SELECT FROM com.nightlabs.ipanema.security.User " +
367             "WHERE " +
368                     " (userType == \"" + User.USERTYPE_USER + "\" ||" +
369                     " userType == \"" + User.USERTYPE_ORGANISATION + "\") && " +
370                     " this.userID != \"" + User.SYSTEM_USERID + "\" && " +
371                     " this.userID != \"" + User.OTHER_USERID + "\"");
372       Collection JavaDoc c = (Collection JavaDoc)query.execute();
373
374       Iterator JavaDoc i = c.iterator();
375       Collection JavaDoc c2 = new HashSet JavaDoc();
376       while(i.hasNext())
377       {
378         Object JavaDoc o = i.next();
379         if(!ug.getUsers().contains(o))
380             c2.add(o);
381       }
382       return pm.detachCopyAll(c2);
383       // workaround end
384

385     }
386     finally
387     {
388       pm.close();
389     }
390   }
391   
392   /**
393    * @throws ModuleException
394    *
395    * @ejb.interface-method
396    * @ejb.permission role-name="UserManager-read"
397    **/

398   public RoleGroupListCarrier getRoleGroups(String JavaDoc userID, String JavaDoc authorityID)
399     throws ModuleException
400   {
401     return getRoleGroups(userID, authorityID, null);
402   }
403   
404   /**
405    * @throws ModuleException
406    *
407    * @ejb.interface-method
408    * @ejb.permission role-name="UserManager-read"
409    **/

410   public RoleGroupListCarrier getRoleGroups(String JavaDoc userID, String JavaDoc authorityID, String JavaDoc [] fetchGroups)
411     throws ModuleException
412   {
413     PersistenceManager pm = getPersistenceManager();
414     try
415     {
416       if (fetchGroups != null)
417         pm.getFetchPlan().setGroups(fetchGroups);
418       else
419         pm.getFetchPlan().clearGroups();
420         
421       Extent ext = pm.getExtent(RoleGroup.class, false);
422
423         // rolegroups via userrefs
424
Query query = pm.newQuery(
425                 "SELECT FROM com.nightlabs.ipanema.security.RoleGroup " +
426                     "WHERE " +
427                     " this == roleGroupRef.roleGroup &&" +
428                     " roleGroupRef.userRefs.containsValue(userRef) &&" +
429                     " userRef.authorityID == paramAuthorityID &&" +
430                     " userRef.user == user &&" +
431                     " user.organisationID == paramOrganisationID &&" +
432                     " user.userID == paramUserID " +
433                     "VARIABLES RoleGroupRef roleGroupRef; UserRef userRef; User user " +
434                     "PARAMETERS String paramOrganisationID, String paramUserID, String paramAuthorityID " +
435                     "IMPORTS import com.nightlabs.ipanema.security.RoleGroupRef; import com.nightlabs.ipanema.security.UserRef; import com.nightlabs.ipanema.security.User; import java.lang.String");
436         Collection JavaDoc roleGroupsUser = (Collection JavaDoc)query.execute(getOrganisationID(), userID, authorityID);
437         
438         // rolegroups via usergroups
439
query = pm.newQuery(
440                 "SELECT FROM com.nightlabs.ipanema.security.RoleGroup " +
441                     "WHERE " +
442                     " this == roleGroupRef.roleGroup &&" +
443                     " roleGroupRef.userRefs.containsValue(userGroupRef) &&" +
444                     " userGroupRef.user == userGroup &&" +
445                     " userGroupRef.authorityID == paramAuthorityID &&" +
446                     " userGroup.users.containsValue(user) &&" +
447                     " user.organisationID == paramOrganisationID &&" +
448                     " user.userID == paramUserID " +
449                     "VARIABLES RoleGroupRef roleGroupRef; UserGroupRef userGroupRef; UserGroup userGroup; User user " +
450                     "PARAMETERS String paramOrganisationID, String paramUserID, String paramAuthorityID " +
451                     "IMPORTS import com.nightlabs.ipanema.security.RoleGroupRef; import com.nightlabs.ipanema.security.UserRef; import java.lang.String");
452         Collection JavaDoc roleGroupsUserGroups = (Collection JavaDoc)query.execute(getOrganisationID(), userID, authorityID);
453
454         RoleGroupListCarrier rglc = new RoleGroupListCarrier();
455         rglc.assignedToUser = pm.detachCopyAll(roleGroupsUser);
456         rglc.assignedToUserGroups = pm.detachCopyAll(roleGroupsUserGroups);
457
458         return rglc;
459     }
460     finally
461     {
462       pm.close();
463     }
464   }
465
466   /**
467    * @throws ModuleException
468    * @throws ModuleException
469    *
470    * @ejb.interface-method
471    * @ejb.permission role-name="UserManager-read"
472    **/

473   public Collection JavaDoc getExcludedRoleGroups(String JavaDoc userID, String JavaDoc authorityID)
474     throws ModuleException
475   {
476     return getExcludedRoleGroups(userID, authorityID, null);
477   }
478   /**
479    * @throws ModuleException
480    *
481    * @ejb.interface-method
482    * @ejb.permission role-name="UserManager-read"
483    **/

484   public Collection JavaDoc getExcludedRoleGroups(String JavaDoc userID, String JavaDoc authorityID, String JavaDoc [] fetchGroups)
485     throws ModuleException
486   {
487     PersistenceManager pm = getPersistenceManager();
488     try
489     {
490       if (fetchGroups != null)
491         pm.getFetchPlan().setGroups(fetchGroups);
492       else
493         pm.getFetchPlan().clearGroups();
494         
495       Extent ext = pm.getExtent(RoleGroup.class, false);
496
497       //FIXME: JPOX bug (INNER JOIN instead of LEFT JOIN)
498
// Query query = pm.newQuery(
499
// "SELECT FROM com.nightlabs.ipanema.security.RoleGroup " +
500
// "WHERE " +
501
// " this == roleGroupRef.roleGroup &&" +
502
// " !(roleGroupRef.userRefs.containsValue(userRef)) &&" +
503
// " userRef.organisationID == paramOrganisationID &&" +
504
// " userRef.userID == paramUserID &&" +
505
// " roleGroupRef.authorityID == paramAuthorityID " +
506
// "VARIABLES RoleGroupRef roleGroupRef; UserRef userRef " +
507
// "PARAMETERS String paramOrganisationID, String paramUserID, String paramAuthorityID " +
508
// "IMPORTS import com.nightlabs.ipanema.security.RoleGroupRef; import com.nightlabs.ipanema.security.UserRef; import java.lang.String");
509
//
510
// Collection res = (Collection)query.execute(getOrganisationID(), userID, authorityID);
511

512 // Query query = pm.newQuery(
513
// "SELECT FROM com.nightlabs.ipanema.security.RoleGroup " +
514
// "WHERE " +
515
// " this == roleGroupRef.roleGroup &&" +
516
// " ! roleGroupRef.userRefs.containsValue(userRef) &&" +
517
// " userRef.authorityID == paramAuthorityID &&" +
518
// " userRef.user == user &&" +
519
// " user.organisationID == paramOrganisationID &&" +
520
// " user.userID == paramUserID " +
521
// "VARIABLES RoleGroupRef roleGroupRef; UserRef userRef; User user " +
522
// "PARAMETERS String paramOrganisationID, String paramUserID, String paramAuthorityID " +
523
// "IMPORTS import com.nightlabs.ipanema.security.RoleGroupRef; import com.nightlabs.ipanema.security.UserRef; import java.lang.String");
524
// Collection res = (Collection)query.execute(getOrganisationID(), userID, authorityID);
525
//
526
// return pm.detachCopyAll(res);
527

528       // workaround start
529
Query query = pm.newQuery("SELECT FROM com.nightlabs.ipanema.security.RoleGroup");
530       Collection JavaDoc c = (Collection JavaDoc)query.execute();
531         query = pm.newQuery(
532                 "SELECT FROM com.nightlabs.ipanema.security.RoleGroup " +
533                     "WHERE " +
534                     " this == roleGroupRef.roleGroup &&" +
535                     " roleGroupRef.userRefs.containsValue(userRef) &&" +
536                     " userRef.authorityID == paramAuthorityID &&" +
537                     " userRef.user == user &&" +
538                     " user.organisationID == paramOrganisationID &&" +
539                     " user.userID == paramUserID " +
540                     "VARIABLES RoleGroupRef roleGroupRef; UserRef userRef; User user " +
541                     "PARAMETERS String paramOrganisationID, String paramUserID, String paramAuthorityID " +
542                     "IMPORTS import com.nightlabs.ipanema.security.RoleGroupRef; import com.nightlabs.ipanema.security.UserRef; import com.nightlabs.ipanema.security.User; import java.lang.String");
543         Collection JavaDoc roleGroupsUser = (Collection JavaDoc)query.execute(getOrganisationID(), userID, authorityID);
544         query = pm.newQuery(
545                 "SELECT FROM com.nightlabs.ipanema.security.RoleGroup " +
546                     "WHERE " +
547                     " this == roleGroupRef.roleGroup &&" +
548                     " roleGroupRef.userRefs.containsValue(userGroupRef) &&" +
549                     " userGroupRef.user == userGroup &&" +
550                     " userGroupRef.authorityID == paramAuthorityID &&" +
551                     " userGroup.users.containsValue(user) &&" +
552                     " user.organisationID == paramOrganisationID &&" +
553                     " user.userID == paramUserID " +
554                     "VARIABLES RoleGroupRef roleGroupRef; UserGroupRef userGroupRef; UserGroup userGroup; User user " +
555                     "PARAMETERS String paramOrganisationID, String paramUserID, String paramAuthorityID " +
556                     "IMPORTS import com.nightlabs.ipanema.security.RoleGroupRef; import com.nightlabs.ipanema.security.UserRef; import java.lang.String");
557         Collection JavaDoc roleGroupsUserGroups = (Collection JavaDoc)query.execute(getOrganisationID(), userID, authorityID);
558       
559       Iterator JavaDoc i = c.iterator();
560       Collection JavaDoc c2 = new HashSet JavaDoc();
561       while(i.hasNext())
562       {
563         Object JavaDoc o = i.next();
564         if((!roleGroupsUser.contains(o)) && (!roleGroupsUserGroups.contains(o)))
565             c2.add(o);
566       }
567       return pm.detachCopyAll(c2);
568       // workaround end
569

570     }
571     finally
572     {
573       pm.close();
574     }
575   }
576
577   /**
578    * @throws ModuleException
579    *
580    * @ejb.interface-method
581    * @ejb.permission role-name="UserManager-read"
582    **/

583   public Collection JavaDoc getUserGroups(String JavaDoc userID)
584     throws ModuleException
585   {
586     return getUserGroups(userID, null);
587   }
588   
589   /**
590    * @throws ModuleException
591    *
592    * @ejb.interface-method
593    * @ejb.permission role-name="UserManager-read"
594    **/

595   public Collection JavaDoc getUserGroups(String JavaDoc userID, String JavaDoc [] fetchGroups)
596     throws ModuleException
597   {
598     PersistenceManager pm = getPersistenceManager();
599     try
600     {
601       if (fetchGroups != null)
602         pm.getFetchPlan().setGroups(fetchGroups);
603       else
604         pm.getFetchPlan().clearGroups();
605
606       Extent ext = pm.getExtent(UserGroup.class, false);
607         Query query = pm.newQuery(
608                 "SELECT FROM com.nightlabs.ipanema.security.UserGroup " +
609                     "WHERE " +
610                     " users.containsKey(paramUserID) " +
611                     "PARAMETERS String paramUserID " +
612                     "IMPORTS import java.lang.String");
613       
614       Collection JavaDoc c = (Collection JavaDoc)query.execute(userID);
615       return pm.detachCopyAll(c);
616     }
617     finally
618     {
619       pm.close();
620     }
621   }
622
623
624   /**
625    * @throws ModuleException
626    *
627    * @ejb.interface-method
628    * @ejb.permission role-name="UserManager-read"
629    **/

630   public Collection JavaDoc getExcludedUserGroups(String JavaDoc userID)
631     throws ModuleException
632   {
633     return getExcludedUserGroups(userID, null);
634   }
635   
636   /**
637    * @throws ModuleException
638    *
639    * @ejb.interface-method
640    * @ejb.permission role-name="UserManager-read"
641    **/

642   public Collection JavaDoc getExcludedUserGroups(String JavaDoc userID, String JavaDoc [] fetchGroups)
643     throws ModuleException
644   {
645     PersistenceManager pm = getPersistenceManager();
646     try
647     {
648       if (fetchGroups != null)
649         pm.getFetchPlan().setGroups(fetchGroups);
650       else
651         pm.getFetchPlan().clearGroups();
652
653       Extent ext = pm.getExtent(UserGroup.class, false);
654       //FIXME: JPOX bug reoccured (negation generates INNER JOIN instead of LEFT OUTER JOIN)
655
// Query query = pm.newQuery(
656
// "SELECT FROM com.nightlabs.ipanema.security.UserGroup " +
657
// "WHERE " +
658
// " !(users.containsKey(paramUserID)) " +
659
// "PARAMETERS String paramUserID " +
660
// "IMPORTS import java.lang.String");
661
//
662
// Collection c = (Collection)query.execute(userID);
663

664      
665       // workaround start
666
Query query = pm.newQuery("SELECT FROM com.nightlabs.ipanema.security.UserGroup");
667       Collection JavaDoc c = (Collection JavaDoc)query.execute();
668         query = pm.newQuery(
669                 "SELECT FROM com.nightlabs.ipanema.security.UserGroup " +
670                     "WHERE " +
671                     " users.containsKey(paramUserID) " +
672                     "PARAMETERS String paramUserID " +
673                     "IMPORTS import java.lang.String");
674       
675       Collection JavaDoc includedUsers = (Collection JavaDoc)query.execute(userID);
676       Iterator JavaDoc i = c.iterator();
677       Collection JavaDoc c2 = new HashSet JavaDoc();
678       while(i.hasNext())
679       {
680         Object JavaDoc o = i.next();
681         if(!includedUsers.contains(o))
682             c2.add(o);
683       }
684       return pm.detachCopyAll(c2);
685       // workaround end
686

687       // return pm.detachCopyAll(c);
688

689     }
690     finally
691     {
692       pm.close();
693     }
694   }
695
696   
697   /**
698    * Check if a user ID exists. Needs role "UserManager-write"; used to check ID while creating new user
699    * @throws ModuleException
700    * @throws ObjectIDException
701    *
702    * @ejb.interface-method
703    * @ejb.permission role-name="UserManager-write"
704    **/

705   public boolean userIDAlreadyRegistered(UserID userID)
706   throws ModuleException, ObjectIDException
707   {
708     PersistenceManager pm = getPersistenceManager();
709     try
710     {
711       Object JavaDoc test = pm.getObjectById(userID, true);
712       LOGGER.debug("userIDAlreadyRegistered(\"" + userID + "\") = " + (test != null));
713       return (test != null);
714     }
715     catch(JDOObjectNotFoundException e)
716     {
717       LOGGER.debug("userIDAlreadyRegistered(\"" + userID + "\") = false");
718       return false;
719     }
720     finally
721     {
722       pm.close();
723     }
724   }
725   
726   /**
727    * Returns a detached user.
728    *
729    * @param userID id of the user
730    * @return the detached user
731    *
732    * @ejb.interface-method
733    * @ejb.permission role-name="UserManager-read"
734    */

735   public User getUser(UserID userID, String JavaDoc [] fetchGroups)
736     throws ModuleException
737   {
738     PersistenceManager pm = this.getPersistenceManager();
739     try
740     {
741       if (fetchGroups != null)
742         pm.getFetchPlan().setGroups(fetchGroups);
743       else
744         pm.getFetchPlan().clearGroups();
745
746       //FIXME: JPOX issue with detached Collections (always attached, problem with dirty bit)
747
//FIXME: JPOX generates invalid SQL when using this workaround
748
// pm.getFetchPlan().addGroup(User.FETCH_GROUP_USERREFS);
749
// workaround end
750

751       pm.getExtent(User.class, true);
752       Object JavaDoc o = pm.getObjectById(userID,true);
753       User usr = (User)pm.detachCopy(o);
754
755       // FIXME: JPOX => load-fetch-group does not work
756
// this workaround makes User.person always dirty before it can be modified by the client (person is
757
// always attached when saving user!)
758
// try
759
// {
760
// Person person = usr.getPerson();
761
// if(person != null)
762
// {
763
// pm.getFetchPlan().setGroups(new String[] {FetchPlan.ALL});
764
// pm.getExtent(User.class, true);
765
// Object p = pm.getObjectById(PersonID.create(getOrganisationID(), person.getPersonID()),true);
766
// usr.setPerson((Person)pm.detachCopy(p));
767
// }
768
// }
769
// catch(JDODetachedFieldAccessException e2)
770
// {
771
// // do nothing
772
// }
773
// workaround end
774

775       return usr;
776     }
777     catch(JDOObjectNotFoundException e)
778     {
779       throw new ModuleException(e);
780     }
781     finally
782     {
783       pm.close();
784     }
785   }
786   
787   /**
788    * @param userID The ID of the user to be returned.
789    * @param includeMask What linked objects shall be included in the transient result. See User.INCLUDE* for details.
790    * @return Returns the User with the given userID. If this user does not exist,
791    * a UserNotFoundException is thrown.
792    *
793    * @ejb.interface-method
794    * @ejb.permission role-name="UserManager-read"
795    * @deprecated
796    **/

797   public User getUser(String JavaDoc userID, int includeMask)
798   throws SecurityException JavaDoc
799   {
800     try {
801       PersistenceManager pm = getPersistenceManager();
802       try {
803         pm.getExtent(User.class, true);
804         try {
805           User user = (User) pm.getObjectById(UserID.create(getOrganisationID(), userID), true);
806           // user = (User)pm.detachCopy(user);
807
user.makeTransient(includeMask);
808           user.setPassword(null);
809           return user;
810         } catch (JDOObjectNotFoundException x) {
811           throw new UserNotFoundException("User \""+userID+"\" not found at organisation \""+getOrganisationID()+"\"!");
812         }
813       } finally {
814         if (AuthorityManagerBean.CLOSE_PM) pm.close();
815       }
816     } catch (SecurityException JavaDoc x) {
817       throw x;
818     } catch (Exception JavaDoc x) {
819       throw new SecurityException JavaDoc(x);
820     }
821   }
822
823
824   /**
825    * Assign rolegroups to a user (should be renamed)
826    * @param userID id of the user
827    * @param authorityID id of the authority for which to get the rolegroups
828    * @param roleGroupIDs Collection of rolegroup IDs
829    * @throws ModuleException
830    *
831    * @ejb.interface-method
832    * @ejb.permission role-name="UserManager-write"
833    **/

834   public void addUserToRoleGroups(String JavaDoc userID, String JavaDoc authorityID, Collection JavaDoc roleGroupIDs)
835     throws ModuleException
836   {
837     Iterator JavaDoc i = roleGroupIDs.iterator();
838     while(i.hasNext())
839     {
840         Object JavaDoc o = i.next();
841         if(o instanceof String JavaDoc)
842             addUserToRoleGroup(userID, authorityID, (String JavaDoc)o);
843     }
844   }
845
846   /**
847    * Assign a rolegroup to a user (should be renamed)
848    * @param userID id of the user
849    * @param authorityID id of the authority the user gets the rolegroup for
850    * @param roleGroupID ID of the rolegroup
851    * @throws ModuleException
852    *
853    * @ejb.interface-method
854    * @ejb.permission role-name="UserManager-write"
855    **/

856   public void addUserToRoleGroup(String JavaDoc userID, String JavaDoc authorityID, String JavaDoc roleGroupID)
857     throws ModuleException
858   {
859     PersistenceManager pm = getPersistenceManager();
860     try
861         {
862         pm.getExtent(Authority.class, true);
863             Authority auth = (Authority)pm.getObjectById(AuthorityID.create(authorityID), true);
864         pm.getExtent(User.class, true);
865             User usr = (User)pm.getObjectById(UserID.create(getOrganisationID(), userID), true);
866         pm.getExtent(RoleGroup.class, true);
867         RoleGroup rg = (RoleGroup)pm.getObjectById(RoleGroupID.create(roleGroupID), true);
868         
869         RoleGroupRef rgf = auth.createRoleGroupRef(rg);
870         UserRef ur = auth.createUserRef(usr);
871         ur.addRoleGroupRef(rgf);
872         }
873     catch(JDOObjectNotFoundException e)
874     {
875       throw new ModuleException(e);
876     }
877     finally
878         {
879         pm.close();
880         }
881   }
882
883   /**
884    * Add users to a usergroup
885    * @param userGoupID id of the user group
886    * @param userIDs Collection of user IDs
887    * @throws SecurityException
888    *
889    * @ejb.interface-method
890    * @ejb.permission role-name="UserManager-write"
891    **/

892   public void addUsersToUserGroup(String JavaDoc userGroupID, Collection JavaDoc userIDs)
893     throws SecurityException JavaDoc
894   {
895     Iterator JavaDoc i = userIDs.iterator();
896     while(i.hasNext())
897     {
898         Object JavaDoc o = i.next();
899         if(o instanceof String JavaDoc)
900             addUserToUserGroup((String JavaDoc)o, userGroupID);
901     }
902   }
903   
904   
905   /**
906    * Add a user to usergroups
907    * @param userID id of the user
908    * @param userGroupIDs Collection of usergroup IDs
909    * @throws SecurityException
910    *
911    * @ejb.interface-method
912    * @ejb.permission role-name="UserManager-write"
913    **/

914   public void addUserToUserGroups(String JavaDoc userID, Collection JavaDoc userGroupIDs)
915     throws SecurityException JavaDoc
916   {
917     Iterator JavaDoc i = userGroupIDs.iterator();
918     while(i.hasNext())
919     {
920         Object JavaDoc o = i.next();
921         if(o instanceof String JavaDoc)
922             addUserToUserGroup(userID, (String JavaDoc)o);
923     }
924   }
925   
926   
927   /**
928    * Add a user to a usergroup
929    * @param userID id of the user
930    * @param userGroupID id of the usergroup
931    * @throws SecurityException
932    *
933    * @ejb.interface-method
934    * @ejb.permission role-name="UserManager-write"
935    **/

936   public void addUserToUserGroup(String JavaDoc userID, String JavaDoc userGroupID)
937   throws SecurityException JavaDoc
938   {
939     try {
940       PersistenceManager pm = getPersistenceManager();
941       try {
942         pm.getExtent(User.class, true);
943         pm.getExtent(UserGroup.class, true);
944         
945         User user;
946         try {
947           user = (User) pm.getObjectById(UserID.create(getOrganisationID(), userID), true);
948         } catch (JDOObjectNotFoundException x) {
949           throw new UserNotFoundException("User \""+userID+"\" not found at organisation \""+getOrganisationID()+"\"!");
950         }
951         
952         UserGroup userGroup;
953         try {
954           User tmpUser = (User) pm.getObjectById(UserID.create(getOrganisationID(), userGroupID), true);
955           
956           if (!(tmpUser instanceof UserGroup))
957             throw new ClassCastException JavaDoc("userGroupID \""+userGroupID+"\" does not represent an object of type UserGroup, but of "+tmpUser.getClass().getName());
958           
959           userGroup = (UserGroup) tmpUser;
960         } catch (JDOObjectNotFoundException x) {
961           throw new UserNotFoundException("UserGroup \""+userGroupID+"\" not found at organisation \""+getOrganisationID()+"\"!");
962         }
963         
964         userGroup.addUser(user);
965         
966       } finally {
967         if (AuthorityManagerBean.CLOSE_PM) pm.close();
968       }
969     } catch (SecurityException JavaDoc x) {
970       throw x;
971     } catch (Exception JavaDoc x) {
972       throw new SecurityException JavaDoc(x);
973     }
974   }
975   
976   /**
977    * Revoke rolegroups from a user (should be renamed)
978    * @param userID id of the user
979    * @param authorityID id of the authority for which the rolegroups are revoked
980    * @param roleGroupIDs Collection of role group IDs
981    * @throws ModuleException
982    *
983      * @ejb.interface-method
984    * @ejb.permission role-name="UserManager-write"
985    **/

986   public void removeUserFromRoleGroups(String JavaDoc userID, String JavaDoc authorityID, Collection JavaDoc roleGroupIDs)
987     throws ModuleException
988   {
989     Iterator JavaDoc i = roleGroupIDs.iterator();
990     while(i.hasNext())
991     {
992         Object JavaDoc o = i.next();
993         if(o instanceof String JavaDoc)
994             removeUserFromRoleGroup(userID, authorityID, (String JavaDoc)o);
995     }
996   }
997
998   /**
999    * Revoke rolegroup from a user (should be renamed)
1000   * @param userID the id of the user
1001   * @param authorityID the id of the authority for which the rolegroup is revoked
1002   * @param roleGroupID the rolegroup id
1003   * @throws ModuleException
1004   *
1005   * @ejb.interface-method
1006   * @ejb.permission role-name="UserManager-write"
1007   **/

1008  public void removeUserFromRoleGroup(String JavaDoc userID, String JavaDoc authorityID, String JavaDoc roleGroupID)
1009    throws ModuleException
1010  {
1011    PersistenceManager pm = getPersistenceManager();
1012    try
1013        {
1014            UserRef uref = (UserRef)pm.getObjectById(UserRefID.create(authorityID, getOrganisationID(), userID), true);
1015            uref.removeRoleGroupRef(roleGroupID);
1016        }
1017    catch(JDOObjectNotFoundException e)
1018    {
1019      throw new ModuleException(e);
1020    }
1021    finally
1022        {
1023        pm.close();
1024        }
1025  }
1026  
1027
1028  /**
1029   * Remove users from usergroup
1030   * @param userGroupID the usergroup ID
1031   * @param userIDs Collection of user IDs
1032   * @throws ModuleException
1033   *
1034   * @ejb.interface-method
1035   * @ejb.permission role-name="UserManager-write"
1036   **/

1037  public void removeUsersFromUserGroup(String JavaDoc userGroupID, Collection JavaDoc userIDs)
1038    throws ModuleException
1039  {
1040    Iterator JavaDoc i = userIDs.iterator();
1041    while(i.hasNext())
1042    {
1043        Object JavaDoc o = i.next();
1044        if(o instanceof String JavaDoc)
1045            removeUserFromUserGroup((String JavaDoc)o, userGroupID);
1046    }
1047  }
1048
1049  /**
1050   * Remove user from usergroups
1051   * @param userID the user ID
1052   * @param userGroupIDs Collection of usergroup IDs
1053   * @throws ModuleException
1054   *
1055   * @ejb.interface-method
1056   * @ejb.permission role-name="UserManager-write"
1057   **/

1058  public void removeUserFromUserGroups(String JavaDoc userID, Collection JavaDoc userGroupIDs)
1059    throws ModuleException
1060  {
1061    Iterator JavaDoc i = userGroupIDs.iterator();
1062    while(i.hasNext())
1063    {
1064        Object JavaDoc o = i.next();
1065        if(o instanceof String JavaDoc)
1066            removeUserFromUserGroup(userID, (String JavaDoc)o);
1067    }
1068  }
1069
1070  
1071  /**
1072   * Remove user from a usergroup
1073   * @param userID the user ID
1074   * @param userGroupID the usergroup ID
1075   * @throws ModuleException
1076   *
1077   * @ejb.interface-method
1078   * @ejb.permission role-name="UserManager-write"
1079   **/

1080  
1081  public void removeUserFromUserGroup(String JavaDoc userID, String JavaDoc userGroupID)
1082  throws ModuleException
1083  {
1084    PersistenceManager pm = getPersistenceManager();
1085    try
1086        {
1087// pm.getExtent(User.class, true);
1088
// User user = (User) pm.getObjectById(UserID.create(getOrganisationID(), userID), true);
1089
pm.getExtent(UserGroup.class, true);
1090        UserGroup userGroup = (UserGroup) pm.getObjectById(UserID.create(getOrganisationID(), userGroupID), true);
1091        
1092        
1093        userGroup.removeUser(userID);
1094        }
1095    catch(JDOObjectNotFoundException e)
1096        {
1097        throw new ModuleException(e);
1098        }
1099    finally
1100        {
1101        pm.close();
1102        }
1103  }
1104
1105  
1106  /**
1107   * Assign a person to a user
1108   * @param userID the user ID
1109   * @param personID the person ID
1110   * @throws ModuleException
1111   *
1112   * @ejb.interface-method
1113   * @ejb.permission role-name="UserManager-write"
1114   **/

1115  
1116  public void assignPersonToUser(String JavaDoc userID, long personID)
1117    throws ModuleException
1118  {
1119    PersistenceManager pm = getPersistenceManager();
1120    try
1121        {
1122        pm.getExtent(User.class, true);
1123        User usr = (User) pm.getObjectById(UserID.create(getOrganisationID(), userID), true);
1124        
1125        pm.getExtent(Person.class, true);
1126        Person ps = (Person) pm.getObjectById(PersonID.create(getOrganisationID(), personID), true);
1127        
1128        usr.setPerson(ps);
1129        }
1130    catch(JDOObjectNotFoundException e)
1131        {
1132        throw new ModuleException(e);
1133        }
1134    finally
1135        {
1136        pm.close();
1137        }
1138  }
1139
1140  
1141  /**
1142     * @ejb.interface-method
1143     * @ejb.permission role-name="_Guest_"
1144     */

1145    public void whoami()
1146        throws ModuleException
1147    {
1148        LOGGER.info("******** WHOAMI: "+getPrincipalString());
1149    }
1150
1151  // /**
1152
// * Normally, there is a timeout of 30 mins until a change at the user rights
1153
// * gets active. To flush the cache immediately, call this method.
1154
// * <br/><br/>
1155
// * <b>Warning! Calling this method might cause trouble to currently logged in
1156
// * users!</b> Thus, you should avoid flushing manually.
1157
// * <br/><br/>
1158
// * Because all users of the current server - and not only the current organisation
1159
// * is affected by this, the privilege "_ServerAdmin_" is required for this method.
1160
// *
1161
// * @throws SecurityException
1162
// *
1163
// * @ejb.interface-method
1164
// * @ejb.permission role-name="_ServerAdmin_"
1165
// * @ejb.transaction type = "Required"
1166
// */
1167
// public void flushAuthenticationCache()
1168
// throws SecurityException
1169
// {
1170
// try {
1171
// IpanemaServerManager ism = getIpanemaServerManager();
1172
// try {
1173
// ism.j2ee_flushAuthenticationCache();
1174
// } finally {
1175
// ism.close();
1176
// }
1177
// } catch (Exception x) {
1178
// throw new SecurityException(x);
1179
// }
1180
// }
1181

1182}
Popular Tags