|
1
7 package com.openedit.modules.admin.users;
8
9 import java.io.File  ;
10 import java.util.ArrayList ;
11 import java.util.HashSet ;
12 import java.util.Iterator ;
13 import java.util.List ;
14 import java.util.Map ;
15 import java.util.Random ;
16 import java.util.Set ;
17
18 import javax.swing.DefaultListModel ;
19
20 import org.apache.commons.logging.Log;
21 import org.apache.commons.logging.LogFactory;
22 import org.openedit.repository.filesystem.StringItem;
23
24 import com.openedit.BaseWebPageRequest;
25 import com.openedit.OpenEditException;
26 import com.openedit.WebPageRequest;
27 import com.openedit.config.XMLConfiguration;
28 import com.openedit.hittracker.HitTracker;
29 import com.openedit.modules.BaseModule;
30 import com.openedit.modules.admin.filemanager.FileUpload;
31 import com.openedit.modules.email.PostMail;
32 import com.openedit.modules.email.Recipient;
33 import com.openedit.modules.email.TemplateWebEmail;
34 import com.openedit.page.Page;
35 import com.openedit.page.PageAction;
36 import com.openedit.page.XconfConfiguration;
37 import com.openedit.users.Group;
38 import com.openedit.users.Permission;
39 import com.openedit.users.User;
40 import com.openedit.users.UserManagerException;
41 import com.openedit.util.PathUtilities;
42 import com.openedit.webui.list.SelectableWebListCellRenderer;
43 import com.openedit.webui.list.WebList;
44
45
49 public class UserManagerModule extends BaseModule
50 {
51 private static final Log log = LogFactory.getLog( UserManagerModule.class );
52
53 public static final String GROUPS = "groups";
54 public static final String USERNAMES = "usernames";
55 public static final String USERMANAGER = "UserManager";
56 public static final String GROUP_NAME_PARAMETER = "groupname";
57 public static final String USERNAME_PARAMETER = "username";
58
59 protected PropertyContainerManipulator fieldPropertyManipulator;
60 protected PostMail postMail;
61 public void createGroup( WebPageRequest inReq ) throws OpenEditException
62 {
63 checkAdminPermission(inReq);
64
65 String name = inReq.getRequiredParameter( GROUP_NAME_PARAMETER );
66
67 try
68 {
69 Group group = getUserManager().createGroup( name );
70
71 for ( Iterator iter = inReq.getParameterMap().entrySet().iterator(); iter.hasNext(); )
74 {
75 Map.Entry entry = (Map.Entry ) iter.next();
76
77 if (entry.getKey().toString().startsWith( "value-" ))
78 {
79 String propertyName = entry.getKey().toString().substring( 6 );
80 group.addPermission( propertyName );
81 }
82 }
83 }
84 catch( UserManagerException ume )
85 {
86 throw new OpenEditException( ume );
87 }
88 }
89
90 public void createGroupProperties( WebPageRequest inReq ) throws OpenEditException,
91 UserManagerException
92 {
93 checkAdminPermission(inReq);
94 Group group = getGroup( inReq );
95 getPropertyContainerManipulator().createProperties( inReq.getParameterMap(),
96 group.getProperties() );
97 getUserManager().saveGroup( group );
98 }
99 public void createGuestAccount(WebPageRequest inReq) throws OpenEditException
100 {
101 String allow = inReq.getPage().get("allowguestregistration");
102 if ( !Boolean.parseBoolean( allow ) )
103 {
104 throw new OpenEditException("Guest registration not allowed.");
105 }
106 else
107 {
108 String username = inReq.getRequestParameter( USERNAME_PARAMETER );
109
110 Random generator = new Random ();
111 String password = Integer.toString((int)(100000 + generator.nextDouble() * 899999D));
112
113 User newUser = getUserManager().createUser(username,password); newUser.setPassword(password);
115 getPropertyContainerManipulator().updateProperties( inReq.getParameterMap(),
116 newUser.getProperties() );
117 Group group = getUserManager().getGroup("guest");
118 if ( group == null)
119 {
120 group = getUserManager().createGroup("guest");
121 }
122 newUser.addGroup(group);
123 getUserManager().saveUser(newUser);
124 getUserManager().saveGroup(group);
125
126 inReq.putPageValue("newuser", newUser);
127
128 try
129 {
130
131 TemplateWebEmail mailer = postMail.getTemplateWebEmail();
132 Page emailLayout = getPageManager().getPage("/openedit/authentication/guestregistrationemail.html");
133 if (!emailLayout.exists()) {
134 throw new OpenEditException("emailLayout" + emailLayout + "does not exist or is invalid");
135 }
136 String subject = emailLayout.get("subject");
137 String from = emailLayout.get("from");
138 mailer.setFrom( from );
139 mailer.setSubject( subject );
140 mailer.setWebPageContext(inReq);
141
143
144 Recipient recipient = new Recipient();
145 String email = inReq.getRequestParameter("value-email");
146 recipient.setEmailAddress(email);
147 mailer.setRecipient(recipient);
148
149 mailer.setMailTemplatePage(emailLayout);
150 mailer.send();
151
152 }
153 catch ( Exception e )
154 {
155 log.error( "Could not send email", e );
156
157 throw new OpenEditException( e );
158 }
159
160 }
161 }
162
163 public void createUser( WebPageRequest inReq ) throws OpenEditException
164 {
165 checkAdminPermission(inReq);
166
167 String username = inReq.getRequiredParameter( USERNAME_PARAMETER );
168 String password = inReq.getRequiredParameter( "password" );
169 String retypedPassword = inReq.getRequiredParameter( "retypedPassword" );
170
171 if (password.equals( retypedPassword ))
172 {
173 try
174 {
175 User user = getUserManager().createUser( username, password );
176 user.setPassword(password);
177 getPropertyContainerManipulator().updateProperties( inReq.getParameterMap(),
178 user.getProperties() );
179 String groups[] = inReq.getRequestParameters(GROUPS);
181 if( groups != null )
182 {
183 for (int i = 0; i < groups.length; i++)
184 {
185 Group group = getUserManager().getGroup( groups[i] );
186 user.addGroup(group);
187 getUserManager().saveGroup(group);
188 }
189 }
190 getUserManager().saveUser( user );
191 inReq.putPageValue( "newUser", user );
192 }
193 catch( UserManagerException ume )
194 {
195 throw new OpenEditException( ume );
196 }
197
198 }
199 else
200 {
201 throw new PasswordMismatchException( "The two passwords did not match." );
202 }
203 }
204
205
206 protected void checkAdminPermission(WebPageRequest inReq) throws OpenEditException
208 {
209 User user = inReq.getUser();
210 if ( user == null)
211 {
212 throw new OpenEditException("Must be logged in");
213 }
214
215 if ( ! (user.hasPermission("oe.usermanager") || user.hasPermission("oe.administration") ) ) {
217 throw new OpenEditException("No Permissions");
218 }
219 }
220
221 public void saveUserGroups( WebPageRequest inReq ) throws OpenEditException
222 {
223 checkAdminPermission(inReq);
224 String username = inReq.getRequiredParameter( USERNAME_PARAMETER );
225
226 try
227 {
228 User user = getUserManager().getUser(username);
229
230 user.clearGroups();
231 String groups[] = inReq.getRequestParameters(GROUPS);
232 if( groups != null )
233 {
234 for (int i = 0; i < groups.length; i++)
235 {
236 Group group = getUserManager().getGroup( groups[i] );
237 user.addGroup( group );
238 }
239 }
240 getUserManager().saveUser( user );
241 }
242 catch( UserManagerException ume )
243 {
244 throw new OpenEditException( ume );
245 }
246 }
247 public void createUserProperties( WebPageRequest inReq ) throws OpenEditException
248 {
249 checkAdminPermission(inReq);
250 try
251 {
252 User user = getUser( inReq );
253 getPropertyContainerManipulator().createProperties( inReq.getParameterMap(),
254 user.getProperties() );
255 getUserManager().saveUser( user );
256 }
257 catch( UserManagerException ume )
258 {
259 throw new OpenEditException( ume );
260 }
261 }
262
263 protected User getUser( WebPageRequest inReq ) throws OpenEditException
264 {
265 String username = inReq.getRequiredParameter( USERNAME_PARAMETER );
266 User user = null;
267
268 try
269 {
270 user = getUserManager().getUser( username );
271
272 return user;
273 }
274 catch( UserManagerException ume )
275 {
276 throw new OpenEditException( ume );
277 }
278
279 }
280
281 public void getGroupsForDeletion( WebPageRequest inReq ) throws OpenEditException
282 {
283 String [] groups = inReq.getRequestParameters( GROUPS );
284 if (groups != null)
285 {
286
287 List groupsForDeletion = new ArrayList ( groups.length );
288 for ( int i = 0; i < groups.length; i++ )
289 {
290 try
291 {
292 Group group = getUserManager().getGroup( groups[i] );
293 groupsForDeletion.add( group );
294 }
295 catch( UserManagerException e )
296 {
297 throw new OpenEditException( e );
298 }
299 }
300 inReq.putPageValue( GROUPS, groupsForDeletion );
301 inReq.putSessionValue( GROUPS, groupsForDeletion );
302 }
303 }
304
305 public void getGroupList( WebPageRequest inReq ) throws OpenEditException
306 {
307 inReq.putPageValue( "groupList", createGroupList() );
308 }
309
310 protected WebList createGroupList()
311 {
312 DefaultListModel model = new DefaultListModel ();
313
314 for ( Iterator iter = getUserManager().getGroups().iterator(); iter.hasNext(); )
315 {
316 model.addElement( iter.next() );
317 }
318
319 WebList list = new WebList( model );
320 list.setName( "deleteGroupNames" );
321 list.setCellRenderer( new SelectableWebListCellRenderer( new GroupListCellRenderer() ) );
322
323 return list;
324 }
325
326 public void getUsersForDeletion( WebPageRequest inReq ) throws OpenEditException
327 {
328 String [] userNames = inReq.getRequestParameters( USERNAMES );
329 if (userNames != null)
330 {
331
332 List usersForDeletion = new ArrayList ( userNames.length );
333 for ( int i = 0; i < userNames.length; i++ )
334 {
335 try
336 {
337 User user = getUserManager().getUser( userNames[i] );
338 if( user != null)
339 {
340 usersForDeletion.add( user );
341 }
342 }
343 catch( UserManagerException e )
344 {
345 throw new OpenEditException( e );
346 }
347 }
348 inReq.putPageValue( USERNAMES, usersForDeletion );
349 inReq.putSessionValue( USERNAMES, usersForDeletion );
350 }
351 }
352
353 public void deleteGroups( WebPageRequest inReq ) throws OpenEditException
354 {
355 checkAdminPermission(inReq);
356 List groups = (List ) inReq.getSessionValue( GROUPS );
357 getUserManager().deleteGroups( groups );
358 inReq.removeSessionValue( GROUPS );
359 }
360
361 public void deleteUsers( WebPageRequest inReq ) throws OpenEditException
362 {
363 checkAdminPermission(inReq);
364 List users = (List ) inReq.getSessionValue( USERNAMES );
365 getUserManager().deleteUsers( users );
366 inReq.removeSessionValue( USERNAMES );
367 }
368
369 public void deleteGroupProperties( WebPageRequest inReq ) throws OpenEditException,
370 OpenEditException
371 {
372 checkAdminPermission(inReq);
373 Group group = getGroup( inReq );
374 getPropertyContainerManipulator().deleteProperties( inReq,
375 group.getProperties() );
376 getUserManager().saveGroup( group );
377 }
378
379 public void deleteUserProperties( WebPageRequest inReq ) throws OpenEditException
380 {
381 try
382 {
383 checkAdminPermission(inReq);
384 User user = getUser( inReq );
385 getPropertyContainerManipulator().deleteProperties( inReq,
386 user.getProperties() );
387 getUserManager().saveUser( user );
388 }
389 catch( UserManagerException e )
390 {
391 throw new OpenEditException( e );
392 }
393 }
394
395 public void getUserManager( WebPageRequest inReq ) throws OpenEditException
396 {
397 inReq.putSessionValue( USERMANAGER, getUserManager() );
398 inReq.putPageValue( USERMANAGER, getUserManager() );
399 }
400
401
406 private String clean( String phone1 )
407 {
408 if (phone1 == null)
409 {
410 return null;
411 }
412 StringBuffer out = new StringBuffer ();
413 for (int i = 0; i < phone1.length(); i++)
414 {
415 if ( Character.isDigit(phone1.charAt(i)))
416 {
417 out.append(phone1.charAt(i));
418 }
419 }
420 phone1 = out.toString();
421
422 return phone1;
423 }
424
425 public void enterUserHomePage( WebPageRequest inReq ) throws Exception
426 {
427 String username = inReq.getRequestParameter("username");
429 String lastname = inReq.getRequestParameter(User.LAST_NAME_PROPERTY);
430 if ( username == null || lastname == null)
431 {
432 String error = "Missing information";
433 inReq.putPageValue("errorMessage",error);
434 log.error( error );
435 return;
436 }
437
438 User user = getUserManager().getUser(username);
439 if ( user == null)
440 {
441 String error = "No such user";
442 inReq.putPageValue("errorMessage",error);
443 log.error( error );
444 return;
445 }
446 if ( lastname == null || !lastname.equalsIgnoreCase( user.getLastName() ) )
447 {
448 String error = "User's last name does not match our records";
449 inReq.putPageValue("errorMessage",error);
450 log.error( error );
451 return;
452 }
453 String directory = inReq.getPath();
454 directory = PathUtilities.extractDirectoryPath(directory);
456 String homepage = directory + "/" + user.getUserName() + "/index.html";
457 com.openedit.page.Page homePage = getPageManager().getPage(homepage);
458 if ( !homePage.exists() )
459 {
460 Page starter = getPageManager().getPage( directory + "/starterpage.html");
462 User admin = getUserManager().getUser("admin");
463 WebPageRequest tempContext = new BaseWebPageRequest( inReq);
464 tempContext.putPageValue("user",admin); getPageManager().copyPage(starter,homePage);
466
467 XconfConfiguration config = new XconfConfiguration();
469 config.setName("page");
470 config.setWritePermissions( "<or><group name=\"administrators\"/><user name=\"" +
472 username + "\" /></or>");
473
474 Page settings = getPageManager().getPage( directory + "/" + user.getUserName() + "/_default.xconf" );
475 StringItem out = new StringItem(settings.getPath(),config.toXml(settings.getCharacterEncoding()),settings.getCharacterEncoding());
476 out.setAuthor(admin.getUserName());
477 out.setMessage("Initial copy");
478 settings.setContentItem(out);
479 getPageManager().putPage(settings);
480 }
481
482 String password = inReq.getRequestParameter("password");
484 if ( password == null || password.length() == 0 )
485 {
486 String phone = inReq.getRequestParameter("phone1");
487 password = clean(phone); }
489 if ( password != null)
490 {
491 boolean ok = getUserManager().authenticate(user, password);
492 if ( ok)
494 {
495 inReq.putSessionValue("user",user);
496 }
497 else
498 {
499 String error = "Incorrect information entered for editing";
500 inReq.putPageValue("errorMessage",error);
501 log.error( error );
502 return;
503 }
504 }
505 inReq.redirect(homePage.getPath());
506 }
507
508
511 public void getUserGroupList( WebPageRequest inReq ) throws OpenEditException
512 {
513 String username = inReq.getRequiredParameter( USERNAME_PARAMETER );
514 User user = null;
515
516 try
517 {
518 user = getUserManager().getUser( username );
519 }
520 catch( UserManagerException ume )
521 {
522 throw new OpenEditException( ume );
523 }
524
525 if (user != null)
526 {
527 inReq.putPageValue( "userGroupList", createUserGroupList( user ) );
528 }
529 }
530
531 protected WebList createUserGroupList( User inUser )
532 {
533 DefaultListModel model = new DefaultListModel ();
534
535 for ( Iterator iter = inUser.getGroups().iterator(); iter.hasNext(); )
536 {
537 model.addElement( iter.next() );
538 }
539
540 WebList list = new WebList( model );
541 list.setCellRenderer( new GroupListCellRenderer() );
542
543 return list;
544 }
545
546
549 public void setUserPassword( WebPageRequest inReq ) throws UserManagerException,
571 OpenEditException
572 {
573
574
575 String password = inReq.getRequestParameter( "password" );
576 String retypedPassword = inReq.getRequestParameter( "retypedPassword" );
577
578 if (password.equals( retypedPassword ))
579 {
580 User user = getUser( inReq );
581 if( user != inReq.getUser() )
582 {
583 checkAdminPermission(inReq);
584 }
585 user.setPassword( password );
586 getUserManager().saveUser( user );
587 }
588 else
589 {
590 throw new PasswordMismatchException( "The two passwords do not match." );
591 }
592 }
593
594
599 protected PropertyContainerManipulator getPropertyContainerManipulator()
600 {
601 if (fieldPropertyManipulator == null)
602 {
603 fieldPropertyManipulator = new PropertyContainerManipulator();
604 }
605
606 return fieldPropertyManipulator;
607 }
608
609 public void saveGroupPermissions( WebPageRequest inReq )
610 throws UserManagerException, OpenEditException
611 {
612 checkAdminPermission(inReq);
613
614 String [] savePermissions = inReq.getRequestParameters( "savePermissions" );
615 String [] permissions = (String []) savePermissions;
616
617 Set permissionsToRetain = new HashSet ();
618 if (permissions != null)
619 {
620 for ( int i = 0; i < permissions.length; i++ )
621 {
622 permissionsToRetain.add( permissions[i] );
623 }
624 }
625
626 for ( Iterator iter = getUserManager().getPermissions().iterator(); iter.hasNext(); )
627 {
628 Group group = getGroup( inReq );
629 Permission element = (Permission) iter.next();
630 boolean dirty = false;
631 if (!permissionsToRetain.contains( element.getName() )
632 && group.hasPermission( element.getName() ))
633 {
634 group.removePermission( element.getName() );
635 dirty = true;
636 }
637 else if (permissionsToRetain.contains( element.getName() )
638 && !group.hasPermission( element.getName() ))
639 {
640 group.addPermission( element.getName() );
641 dirty = true;
642 }
643 if ( dirty)
644 {
645 getUserManager().saveGroup(group);
646 }
647 }
648 }
649
650
653 public void updateUserProperties( WebPageRequest inReq ) throws UserManagerException,
654 OpenEditException
655 {
656 checkAdminPermission(inReq);
657 User user = getUser( inReq );
658 getPropertyContainerManipulator().updateProperties( inReq.getParameterMap(),
659 user.getProperties() );
660 getUserManager().saveUser( user );
661 }
662
663
666 public void updateGroupProperties( WebPageRequest inReq ) throws UserManagerException,
667 OpenEditException
668 {
669 checkAdminPermission(inReq);
670 Group group = getGroup( inReq );
671 getPropertyContainerManipulator().updateProperties( inReq.getParameterMap(),
672 group.getProperties() );
673 getUserManager().saveGroup(group);
674 }
675
676
679 public void addUsersToGroup( WebPageRequest inReq ) throws UserManagerException,
680 OpenEditException
681 {
682 inReq.removeSessionValue("cachedGroupQuery");
683 checkAdminPermission(inReq);
684 String [] userNames = inReq.getRequestParameters( "addUsernames" );
685 Group group = getGroup( inReq );
686
687 if (userNames != null)
688 {
689 for ( int i = 0; i < userNames.length; i++ )
690 {
691 User user = getUserManager().getUser( userNames[i] );
692
693 if( user == null)
694 {
695 user = getUserManager().getUserByEmail(userNames[i]);
696 }
697
698 if (user == null)
699 {
700 throw new UserManagerException( "Could not find user " + userNames[i] );
701 }
702 user.addGroup(group );
703 getUserManager().saveUser(user);
704 }
705 getUserManager().saveGroup(group);
706 }
707 }
708
709
712 protected Group getGroup( WebPageRequest inReq ) throws OpenEditException
713 {
714 String name = inReq.getRequestParameter( GROUP_NAME_PARAMETER );
715
716 if ( name == null)
717 {
718 PageAction action = (PageAction)inReq.getPageValue("exec-action");
719 if ( action != null)
720 {
721 name = action.getChildValue("groupname");
722 }
723
724 }
725
726 Group group = null;
727
728 try
729 {
730 group = getUserManager().getGroup( name );
731
732 return group;
733 }
734 catch( UserManagerException ume )
735 {
736 throw new OpenEditException( ume );
737 }
738 }
739 public void loadGroup( WebPageRequest inReq) throws OpenEditException
740 {
741 Group group = getGroup(inReq);
742 inReq.putPageValue("group",group);
743 }
744
747 public void removeUsersFromGroup( WebPageRequest inReq ) throws UserManagerException,
748 OpenEditException
749 {
750
751 checkAdminPermission(inReq);
752 inReq.removeSessionValue("cachedGroupQuery");
753
754 String [] userNames = inReq.getRequestParameters( "removeUsernames" );
755
756 if (userNames != null)
757 {
758 Group group = getGroup(inReq);
759 for ( int i = 0; i < userNames.length; i++ )
760 {
761 User user = getUserManager().getUser( userNames[i] );
762
763 if (user != null)
764 {
765 user.removeGroup(group);
766 getUserManager().saveUser(user);
767 }
768 }
769 getUserManager().saveGroup(group);
770
771 }
772 }
773 public void removeAllUsersFromGroup( WebPageRequest inReq ) throws UserManagerException, OpenEditException
774 {
775 checkAdminPermission(inReq); inReq.removeSessionValue("cachedGroupQuery");
777 Group group = getGroup(inReq);
778
779 HitTracker users = getUserManager().getUsersInGroup(group);
780 for (Iterator iter = users.iterator(); iter.hasNext();)
781 {
782 User user = (User) iter.next();
783 user.removeGroup(group);
784 getUserManager().saveUser(user);
785 }
786 getUserManager().saveGroup(group);
787 }
788
789 public void getGroupUserList(WebPageRequest inReq) throws OpenEditException
790 {
791 String groupName = inReq.getRequiredParameter( GROUP_NAME_PARAMETER);
792 Group group = null;
793
794 try
795 {
796 group = getUserManager().getGroup(groupName);
797 }
798 catch (UserManagerException ume)
799 {
800 throw new OpenEditException(ume);
801 }
802
803 if (group != null)
804 {
805 inReq.putPageValue("groupUserList", createGroupUserList(group));
806 }
808 }
809
810
817 protected WebList createGroupUserList(Group inGroup)
818 {
819 DefaultListModel model = new DefaultListModel ();
820
821 HitTracker users = getUserManager().getUsersInGroup(inGroup);
822 for (Iterator iter = users.iterator(); iter.hasNext();)
823 {
824 model.addElement(iter.next());
825 }
826
827 WebList list = new WebList(model);
828 list.setName("removeUsernames");
829 list.setCellRenderer(new SelectableWebListCellRenderer(new UserListCellRenderer()));
830
831 return list;
832 }
833
834
841 public void loadUserProperties(WebPageRequest inReq) throws Exception
863 {
864 Page config = getPageManager().getPage("/openedit/usermanager/usermanagersettings.xml");
865 XMLConfiguration notificationConfig = new XMLConfiguration();
866 notificationConfig.readXML(config.getReader());
867 List children = notificationConfig.getChildren("userproperty");
868 inReq.putPageValue("standarduserproperties",children);
869
870 String userName = inReq.getRequestParameter( "username" );
871 if( userName != null)
872 {
873 User user = getUserManager().getUser( userName );
874 inReq.putPageValue( "propertycontainer", user );
875 inReq.putPageValue( "selectedUser", user );
876 inReq.putPageValue( "userName", user.getUserName());
877 }
878 }
880
881 public void importAccounts( WebPageRequest inReq) throws OpenEditException
882 {
883 checkAdminPermission(inReq);
884
888 FileUpload command = new FileUpload();
889 command.setPageManager(getPageManager());
890 Map properties = command.parseArguments(inReq);
891 if ( properties == null)
892 {
893 return;
894 }
895 String id = (String )properties.get("groupname");
896 if ( id == null)
897 {
898 id = inReq.getRequestParameter("groupname"); }
900 if ( id != null && id.length() > 0)
903 {
904 try
905 {
906 File temp = null;
907 String input = inReq.getRequestParameter("inputfile"); if ( input != null)
909 {
910 temp = new File ( input );
911 }
912 else
913 {
914 Page page = command.saveFile(properties,"/WEB-INF/trash/userimport.tsv",inReq);
916 temp = new File ( getRoot(), page.getPath() );
917 }
918 UserImport uimport = new UserImport();
921 uimport.setUserManager(getUserManager());
922 List users = uimport.listUsers(temp);
923
924 Group group = getUserManager().getGroup(id);
925
926 for (Iterator iter = users.iterator(); iter.hasNext();)
927 {
928 User user = (User) iter.next();
929 user.addGroup(group);
930 getUserManager().saveUser(user);
931 }
932 }
933 catch ( Exception ex)
934 {
935 throw new OpenEditException(ex);
936 }
937 }
938 }
939
940 public void findUsers(WebPageRequest inReq)
941 {
942 String query = inReq.getRequestParameter("query");
943
944 int pagenum = 1;
945 String page = inReq.getRequestParameter("page");
946 if (page != null)
947 {
948 pagenum = Integer.parseInt(page);
949 }
950
951
952
960 if (query == null)
961 {
962 HitTracker tracker = (HitTracker)inReq.getSessionValue("userTracker");
963 if ( tracker != null)
964 {
965 tracker.setPage(pagenum);
966 }
967 }
970 else
971 {
972 HitTracker tracker = getUserManager().findUser(query);
973 tracker.setHitsPerPage(25);
974 inReq.putSessionValue("userTracker", tracker);
975 inReq.putSessionValue("cachedUserQuery", query);
976 }
977
978 }
979
980 public void findUsersInGroup(WebPageRequest inReq)
981 {
982 int pagenum = 1;
983 String page = inReq.getRequestParameter("page");
984 if (page != null)
985 {
986 pagenum = Integer.parseInt(page);
987 }
988
989 String group = inReq.getRequestParameter("groupname");
990
991 String cachedGroup = (String )inReq.getSessionValue("cachedGroupQuery");
992 if (group == null)
993 {
994 group = cachedGroup;
995 }
996
997 HitTracker tracker = null;
998
999 if (cachedGroup != null && cachedGroup.equals(group))
1000 {
1001 tracker = (HitTracker)inReq.getSessionValue("groupTracker");
1002 }
1003 if (tracker == null)
1004 {
1005 tracker = getGroupHits(group);
1006 }
1007
1008 tracker.setPage(pagenum);
1009 inReq.putSessionValue("groupTracker", tracker);
1010 inReq.putSessionValue("cachedGroupQuery", group);
1011 }
1012
1013 public HitTracker getGroupHits(String inGroup)
1014 {
1015 HitTracker users = getUserManager().getUsersInGroup(inGroup);
1016 return users;
1017 }
1018
1019 public PostMail getPostMail() {
1020 return postMail;
1021 }
1022
1023 public void setPostMail(PostMail postMail) {
1024 this.postMail = postMail;
1025 }
1026} |
Popular Tags |
Java API By Example, From Geeks To Geeks.