KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > jboss > portal > core > portlet > role > RolePortlet


1 /*****************************************
2  * *
3  * JBoss Portal: The OpenSource Portal *
4  * *
5  * Distributable under LGPL license. *
6  * See terms of license at gnu.org. *
7  * *
8  *****************************************/

9 package org.jboss.portal.core.portlet.role;
10
11 import org.jboss.logging.Logger;
12 import org.jboss.portal.common.context.DelegateContext;
13 import org.jboss.portal.core.model.Role;
14 import org.jboss.portal.core.model.User;
15 import org.jboss.portal.core.modules.ModuleConstants;
16 import org.jboss.portal.core.modules.ModuleException;
17 import org.jboss.portal.core.modules.RoleModule;
18 import org.jboss.portal.core.modules.UserModule;
19 import org.jboss.portal.core.portlet.PortletHelper;
20 import org.jboss.portal.core.portlet.user.UserPortletConstants;
21 import org.jboss.portal.core.servlet.jsp.PortalJsp;
22 import org.jboss.portlet.*;
23
24 import javax.naming.InitialContext JavaDoc;
25 import javax.naming.NamingException JavaDoc;
26 import javax.portlet.*;
27 import java.io.IOException JavaDoc;
28 import java.io.PrintWriter JavaDoc;
29 import java.util.Iterator JavaDoc;
30 import java.util.Locale JavaDoc;
31 import java.util.ResourceBundle JavaDoc;
32 import java.util.Set JavaDoc;
33
34 /**
35  * This portlet aims at managing roles of users.
36  *
37  * @author <a HREF="mailto:noel.rocher@free.fr">Noel Rocher</a>
38  * @author <a HREF="mailto:julien@jboss.org">Julien Viet</a>
39  * @author <a HREF="mailto:theute@jboss.org">Thomas Heute </a>
40  * @author Roy Russo : roy at jboss dot org
41  * @version $Revision: 1.13 $
42  */

43 public class RolePortlet
44       extends JBossPortlet
45 {
46    /**
47     * the class logger
48     */

49    public static final Logger log = Logger.getLogger(JBossPortlet.class);
50
51    private PortletHelper portletHelper;
52
53    // Render op
54
public static final String JavaDoc OP_SHOWSUMMARY = "showSummary";
55
56    public static final String JavaDoc OP_SHOWCREATEROLE = "showCreateRole";
57
58    public static final String JavaDoc OP_SHOWEDITROLE = "showEditRole";
59
60    /**
61     * Main Edit role page where admins can filter
62     */

63    public static final String JavaDoc OP_SHOWMAINROLEMEMBERS = "showMainEditRoleMembers";
64
65    /**
66     * Edit role page where admins can edit the members individually.
67     */

68    public static final String JavaDoc OP_SHOWLISTROLEMEMBERS = "showListEditRoleMembers";
69
70    /**
71     * Render operation to show the screen to assign roles to a user
72     */

73    public static final String JavaDoc OP_SHOWADDROLESTOUSER = "showAddRolesToUser";
74
75    private RoleModule roleModule;
76
77    private UserModule userModule;
78
79    public void init() throws PortletException
80    {
81       super.init();
82       try
83       {
84          userModule = (UserModule) new InitialContext JavaDoc()
85                .lookup(ModuleConstants.USERMODULE_JNDINAME);
86          roleModule = (RoleModule) new InitialContext JavaDoc()
87                .lookup(ModuleConstants.ROLEMODULE_JNDINAME);
88       }
89       catch(NamingException JavaDoc e)
90       {
91          throw new PortletException(e);
92       }
93       portletHelper = new PortletHelper(this);
94    }
95
96    public String JavaDoc getDefaultOperation()
97    {
98       return OP_SHOWSUMMARY;
99    }
100
101    protected void doView(JBossRenderRequest req, JBossRenderResponse resp)
102          throws PortletException, PortletSecurityException, IOException JavaDoc
103    {
104       if(req.hasPermission("Admin"))
105       {
106          resp.setContentType("text/html");
107          PrintWriter JavaDoc writer = resp.getWriter();
108
109          String JavaDoc op;
110          if(req.getWindowState() != WindowState.MAXIMIZED)
111          {
112             op = getDefaultOperation();
113          }
114          else
115          {
116             op = req.getParameters().get(getOperationName(),
117                                          getDefaultOperation());
118          }
119
120          Locale JavaDoc locale = req.getLocale();
121          ResourceBundle JavaDoc bundle = getResourceBundle(locale);
122          if(OP_SHOWSUMMARY.equals(op))
123          {
124             if(req.hasPermission("Admin"))
125             {
126                DelegateContext ctx = new DelegateContext();
127                ctx.put("nbRoles", getNbRolesString(bundle));
128                req.setAttribute(PortalJsp.CTX_REQUEST, ctx);
129                PortletRequestDispatcher rd = getPortletContext()
130                      .getRequestDispatcher("/WEB-INF/jsp/role/menu.jsp");
131                rd.include(req, resp);
132             }
133          }
134          else if(OP_SHOWCREATEROLE.equals(op))
135          {
136             if(req.hasPermission("Admin"))
137             {
138                PortletRequestDispatcher rd = getPortletContext()
139                      .getRequestDispatcher("/WEB-INF/jsp/role/createRole.jsp");
140                rd.include(req, resp);
141             }
142          }
143          else if(OP_SHOWEDITROLE.equals(op))
144          {
145             if(req.hasPermission("Admin"))
146             {
147                try
148                {
149                   Set JavaDoc roles = roleModule.findRoles();
150                   DelegateContext ctx = new DelegateContext();
151                   Iterator JavaDoc i = roles.iterator();
152                   DelegateContext roleCtx = null;
153                   while(i.hasNext())
154                   {
155                      Role role = (Role) i.next();
156                      roleCtx = ctx.next("role");
157                      String JavaDoc roleId = role.getID().toString();
158                      roleCtx.put("id", roleId);
159                      roleCtx.put("displayname", role.getDisplayName());
160                      String JavaDoc selectedRoleId = req.getParameter("roleid");
161                      if(roleId.equals(selectedRoleId))
162                      {
163                         roleCtx.put("selected", "selected");
164                      }
165                   }
166                   req.setAttribute(PortalJsp.CTX_REQUEST, ctx);
167                }
168                catch(ModuleException e)
169                {
170                   // TODO Auto-generated catch block
171
e.printStackTrace();
172                }
173                PortletRequestDispatcher rd = getPortletContext()
174                      .getRequestDispatcher("/WEB-INF/jsp/role/editRole.jsp");
175                rd.include(req, resp);
176             }
177          }
178          else if(OP_SHOWMAINROLEMEMBERS.equals(op))
179          {
180             if(req.hasPermission("Admin"))
181             {
182                try
183                {
184                   Set JavaDoc roles = roleModule.findRoles();
185                   DelegateContext ctx = new DelegateContext();
186                   Iterator JavaDoc i = roles.iterator();
187                   DelegateContext roleCtx = null;
188                   while(i.hasNext())
189                   {
190                      Role role = (Role) i.next();
191                      roleCtx = ctx.next("role");
192                      String JavaDoc roleId = role.getID().toString();
193                      roleCtx.put("id", roleId);
194                      roleCtx.put("displayname", role.getDisplayName());
195                      String JavaDoc selectedRoleId = req.getParameter("roleid");
196                      if(roleId.equals(selectedRoleId))
197                      {
198                         roleCtx.put("selected", "selected");
199                      }
200                   }
201                   req.setAttribute(PortalJsp.CTX_REQUEST, ctx);
202                }
203                catch(ModuleException e)
204                {
205                   // TODO Auto-generated catch block
206
e.printStackTrace();
207                }
208                PortletRequestDispatcher rd = getPortletContext()
209                      .getRequestDispatcher("/WEB-INF/jsp/role/editRoleMembers.jsp");
210                rd.include(req, resp);
211             }
212          }
213          else if(OP_SHOWLISTROLEMEMBERS.equals(op))
214          {
215             if(req.hasPermission("Admin"))
216             {
217                try
218                {
219                   Integer JavaDoc roleID = req.getParameters().getIntObject("roleid");
220                   Role role = roleModule.findRoleByID(roleID);
221
222                   DelegateContext ctx = new DelegateContext();
223                   DelegateContext roleCtx = null;
224                   roleCtx = ctx.next("role");
225                   ctx.put("displayname", role.getDisplayName());
226
227                   int offset = req.getParameters().getInt("offset", 0);
228                   int usersPerPage = req.getParameters().getInt("usersperpage", UserPortletConstants.DEFAULT_USERSPERPAGE);
229                   String JavaDoc usernameFilter = req.getParameters().get("usernamefilter", "");
230                   ctx.put("usernameFilter", usernameFilter);
231
232                   Set JavaDoc users = null;
233                   users = roleModule.findRoleMembers(role.getName(), offset, usersPerPage + 1, usernameFilter.trim());
234
235                   User[] usersArray = new User[users.size()];
236                   usersArray = (User[]) users.toArray(usersArray);
237
238                   DelegateContext rowCtx = null;
239                   for(int i = 0; i < Math.min(usersArray.length, usersPerPage); i++)
240                   {
241                      int oddeven = i % 2;
242                      User user = usersArray[i];
243                      if(oddeven == 0)
244                      {
245                         rowCtx = ctx.next("row");
246                      }
247
248                      rowCtx.put("fullname" + oddeven, getFullName(bundle, user));
249                      rowCtx.put("username" + oddeven, user.getUserName());
250
251                      //
252
Iterator JavaDoc itRoles = user.getRoles().iterator();
253                      while(itRoles.hasNext())
254                      {
255                         DelegateContext rolesCtx = rowCtx.next("roles" + oddeven);
256                         rolesCtx.put("name", ((Role) itRoles.next()).getDisplayName());
257                      }
258
259                      PortletURL editURL = resp.createRenderURL();
260                      editURL.setParameter(getOperationName(), OP_SHOWADDROLESTOUSER);
261                      editURL.setParameter("userid", "" + user.getID());
262
263                      rowCtx.put("editURL" + oddeven, editURL.toString());
264                   }
265
266                   if(offset != 0)
267                   {
268                      PortletURL previousPageLink = resp.createRenderURL();
269                      previousPageLink.setParameter(getOperationName(), OP_SHOWLISTROLEMEMBERS);
270                      previousPageLink.setParameter("offset", "" + Math.max(0, offset - usersPerPage));
271                      previousPageLink.setParameter("usersperpage", "" + usersPerPage);
272                      previousPageLink.setParameter("usernamefilter", usernameFilter);
273                      previousPageLink.setParameter("roleid", "" + roleID);
274                      DelegateContext previousCtx = ctx.next("previouspage");
275                      previousCtx.put("link", previousPageLink.toString());
276                   }
277
278                   if(usersArray.length > usersPerPage)
279                   {
280                      PortletURL nextPageLink = resp.createRenderURL();
281                      nextPageLink.setParameter(getOperationName(), OP_SHOWLISTROLEMEMBERS);
282                      nextPageLink.setParameter("offset", "" + (offset + usersPerPage));
283                      nextPageLink.setParameter("usersperpage", "" + usersPerPage);
284                      nextPageLink.setParameter("usernamefilter", usernameFilter);
285                      nextPageLink.setParameter("roleid", "" + roleID);
286                      DelegateContext nextCtx = ctx.next("nextpage");
287                      nextCtx.put("link", nextPageLink.toString());
288                   }
289
290                   ctx.put("usernamefilter", usernameFilter);
291                   req.setAttribute(PortalJsp.CTX_REQUEST, ctx);
292                }
293                catch(ModuleException e)
294                {
295                   // TODO Auto-generated catch block
296
e.printStackTrace();
297                }
298                PortletRequestDispatcher rd = getPortletContext()
299                      .getRequestDispatcher("/WEB-INF/jsp/role/editListRoleMembers.jsp");
300                rd.include(req, resp);
301             }
302          }
303          else if(OP_SHOWADDROLESTOUSER.equals(op))
304          {
305             if(req.hasPermission("Admin"))
306             {
307                DelegateContext ctx = new DelegateContext();
308
309                try
310                {
311                   User user = userModule.findUserByID(req.getParameters().getIntObject("userid"));
312                   ctx.put("userid", user.getID());
313                   ctx.put("username", user.getUserName());
314                   ctx.put("userfullname", getFullName(bundle, user));
315                   Set JavaDoc userRoles = user.getRoles();
316
317                   Set JavaDoc roles = roleModule.findRoles();
318                   Role[] rolesArray = new Role[roles.size()];
319                   rolesArray = (Role[]) roles.toArray(rolesArray);
320                   Role role = null;
321                   DelegateContext rowCtx = null;
322                   for(int i = 0; i < rolesArray.length; i++)
323                   {
324                      int oddeven = i % 3;
325                      role = rolesArray[i];
326                      if(oddeven == 0)
327                      {
328                         rowCtx = ctx.next("row");
329                      }
330
331                      DelegateContext colCtx = rowCtx.next("col");
332                      if(userRoles.contains(role))
333                      {
334                         colCtx.put("ischecked", "checked");
335                      }
336
337                      colCtx.put("name", role.getName());
338                      colCtx.put("displayname", role.getDisplayName());
339                   }
340                }
341                catch(IllegalArgumentException JavaDoc e)
342                {
343                   // TODO Auto-generated catch block
344
e.printStackTrace();
345                }
346                catch(ModuleException e)
347                {
348                   // TODO Auto-generated catch block
349
e.printStackTrace();
350                }
351
352                req.setAttribute(PortalJsp.CTX_REQUEST, ctx);
353                PortletRequestDispatcher rd = getPortletContext().getRequestDispatcher("/WEB-INF/jsp/role/editUserRoles.jsp");
354                rd.include(req, resp);
355             }
356          }
357          else
358          {
359             log.error("This operation does not exist when user is logged in:"
360                       + op);
361          }
362          writer.close();
363       }
364       else
365       {
366          forbidden(req, resp);
367       }
368    }
369
370    /**
371     * Handles permissions errors on doView.
372     *
373     * @param rReq
374     * @param rRes
375     * @throws javax.portlet.PortletException
376     * @throws IOException
377     */

378    private void forbidden(javax.portlet.RenderRequest rReq, javax.portlet.RenderResponse rRes) throws javax.portlet.PortletException, IOException JavaDoc
379    {
380       rRes.setContentType("text/html");
381       javax.portlet.PortletRequestDispatcher prd = getPortletContext().getRequestDispatcher("/WEB-INF/jsp/permission/forbidden.jsp");
382       prd.include(rReq, rRes);
383    }
384
385    public void createRole(JBossActionRequest req, JBossActionResponse resp)
386    {
387       if(req.hasPermission("Admin"))
388       {
389
390          String JavaDoc roleName = req.getParameter("rolename");
391          String JavaDoc roleDisplayName = req.getParameter("roledisplayname");
392          if((roleName != null) && (roleDisplayName != null)
393             && (roleName.length() != 0) && (roleDisplayName.length() != 0))
394          {
395             if(roleByDisplayNameAvailable(roleDisplayName)
396                && roleByNameAvailable(roleName))
397             {
398                try
399                {
400                   roleModule.createRole(roleName, roleDisplayName);
401                   try
402                   {
403                      resp.setRenderParameter(getOperationName(),
404                                              getDefaultOperation());
405                      resp.setWindowState(WindowState.NORMAL);
406                   }
407                   catch(WindowStateException e1)
408                   {
409                      log.error("Couldn't put the window in normal state");
410                   }
411                }
412                catch(IllegalArgumentException JavaDoc e)
413                {
414                   log.error("Cannot create role, rolename is null");
415                   e.printStackTrace();
416                }
417                catch(ModuleException e)
418                {
419                   log.error("Cannot create role \"" + roleName
420                             + "\", unexpected error");
421                   e.printStackTrace();
422                }
423             }
424             else
425             {
426                if(!roleByDisplayNameAvailable(roleDisplayName))
427                {
428                   // Role with that display name already exists !
429
portletHelper.setRenderParameter(resp, "rolename", roleName);
430                   portletHelper.setRenderParameter(resp, "roledisplayname",
431                                                    roleDisplayName);
432                   resp.setRenderParameter("roledisplayname_error",
433                                           "ROLE_ERROR_DISPLAYNAMEALREADYEXISTS");
434                   resp
435                         .setRenderParameter(getOperationName(),
436                                             OP_SHOWCREATEROLE);
437                }
438                else if(!roleByNameAvailable(roleName))
439                {
440                   // Role with that name already exists !
441
portletHelper.setRenderParameter(resp, "rolename", roleName);
442                   portletHelper.setRenderParameter(resp, "roledisplayname",
443                                                    roleDisplayName);
444                   resp.setRenderParameter("rolename_error",
445                                           "ROLE_ERROR_NAMEALREADYEXISTS");
446                   resp
447                         .setRenderParameter(getOperationName(),
448                                             OP_SHOWCREATEROLE);
449                }
450             }
451          }
452          else
453          {
454             // Role name or displayname empty
455
portletHelper.setRenderParameter(resp, "rolename", roleName);
456             portletHelper.setRenderParameter(resp, "roledisplayname",
457                                              roleDisplayName);
458             if(roleName == null || roleName.length() == 0)
459             {
460                resp
461                      .setRenderParameter("rolename_error",
462                                          "ROLE_ERROR_NAMEEMPTY");
463             }
464             if(roleDisplayName == null || roleDisplayName.length() == 0)
465             {
466                resp.setRenderParameter("roledisplayname_error",
467                                        "ROLE_ERROR_DISPLAYNAMEEMPTY");
468             }
469             resp.setRenderParameter(getOperationName(), OP_SHOWCREATEROLE);
470          }
471       }
472    }
473
474    /**
475     * Action to edit a role
476     *
477     * @param req
478     * @param resp
479     */

480    public void editRole(JBossActionRequest req, JBossActionResponse resp)
481    {
482       if(req.hasPermission("Admin"))
483       {
484          Integer JavaDoc roleID = req.getParameters().getIntObject("roleid");
485          String JavaDoc newDisplayName = req.getParameter("roledisplayname");
486          Role role = null;
487          try
488          {
489             role = roleModule.findRoleByID(roleID);
490             // Check that the new display name is available
491
if(roleByDisplayNameAvailable(newDisplayName))
492             {
493                role.setDisplayName(newDisplayName);
494             }
495             else
496             // The display name is not available, go back to the prefilled form
497
{
498                portletHelper.setRenderParameter(resp, "roledisplayname",
499                                                 newDisplayName);
500                portletHelper.setRenderParameter(resp, "roleid", roleID
501                                                                 .toString());
502                resp.setRenderParameter("roledisplayname_error",
503                                        "ROLE_ERROR_DISPLAYNAMEALREADYEXISTS");
504                resp.setRenderParameter(getOperationName(), OP_SHOWEDITROLE);
505             }
506          }
507          catch(IllegalArgumentException JavaDoc e)
508          {
509             log.error("Cannot update role: roleID is null");
510             e.printStackTrace();
511          }
512          catch(ModuleException e)
513          {
514             log.error("Cannot update role, unexpected error");
515             e.printStackTrace();
516          }
517       }
518    }
519
520    /**
521     * Adds or Removes roles from a user.
522     *
523     * @param request
524     * @param response
525     */

526    public void addRolesToUser(JBossActionRequest request, JBossActionResponse response)
527    {
528       if(request.hasPermission("Admin"))
529       {
530          String JavaDoc[] selectedRoles = request.getParameterValues("roles");
531          Integer JavaDoc userId = request.getParameters().getIntObject("userid");
532          try
533          {
534             User user = userModule.findUserByID(userId);
535             Set JavaDoc roles = roleModule.findRolesByNames(selectedRoles);
536             user.setRoles(roles);
537          }
538          catch(IllegalArgumentException JavaDoc e)
539          {
540             // TODO Auto-generated catch block
541
e.printStackTrace();
542          }
543          catch(ModuleException e)
544          {
545             // TODO Auto-generated catch block
546
e.printStackTrace();
547          }
548       }
549    }
550
551    /**
552     * Action to delete a role
553     *
554     * @param req
555     * @param resp
556     */

557    public void removeRole(JBossActionRequest req, JBossActionResponse resp)
558    {
559       if(req.hasPermission("Admin"))
560       {
561          Integer JavaDoc roleID = req.getParameters().getIntObject("roleid");
562          try
563          {
564             roleModule.removeRole(roleID);
565             resp.setRenderParameter("roledelete_error", "ROLE_DELETED");
566             resp.setRenderParameter(getOperationName(), OP_SHOWEDITROLE);
567          }
568          catch(ModuleException e)
569          {
570             log.error("Cannot remove role, unexpected error");
571             e.printStackTrace();
572             portletHelper.setRenderParameter(resp, "roleid", roleID.toString());
573             resp.setRenderParameter("roledelete_error",
574                                     "ROLE_ERROR_DELETE_FAILED");
575             resp.setRenderParameter(getOperationName(), OP_SHOWEDITROLE);
576          }
577       }
578    }
579
580    /**
581     * Returns true if the role with display name in argument is available
582     *
583     * @param name Display name of the role to check
584     * @return true if the display name is available
585     */

586    private boolean roleByDisplayNameAvailable(String JavaDoc name)
587    {
588       Role role = null;
589       try
590       {
591          role = roleModule.findRoleByDisplayName(name);
592       }
593       catch(IllegalArgumentException JavaDoc e)
594       {
595          e.printStackTrace();
596       }
597       catch(ModuleException e)
598       {
599          return true;
600       }
601       return false;
602    }
603
604    /**
605     * Returns true if the role with name in argument is available
606     */

607    private boolean roleByNameAvailable(String JavaDoc name)
608    {
609       Role role = null;
610       try
611       {
612          role = roleModule.findRoleByName(name);
613       }
614       catch(IllegalArgumentException JavaDoc e)
615       {
616          e.printStackTrace();
617       }
618       catch(ModuleException e)
619       {
620          return true;
621       }
622       return false;
623    }
624
625    /**
626     * Return a localized sentence stating the number of existing roles
627     */

628    private String JavaDoc getNbRolesString(ResourceBundle JavaDoc bundle)
629    {
630       StringBuffer JavaDoc buffer = new StringBuffer JavaDoc();
631       int nbRoles = 0;
632       try
633       {
634          nbRoles = roleModule.getRolesCount();
635       }
636       catch(IllegalArgumentException JavaDoc e)
637       {
638          e.printStackTrace();
639       }
640       catch(ModuleException e)
641       {
642          e.printStackTrace();
643       }
644       if(nbRoles <= 1)
645       {
646          buffer.append(bundle.getString("ROLE_THEREIS")).append(" ");
647          if(nbRoles == 0)
648          {
649             buffer.append("no");
650          }
651          else
652          {
653             buffer.append("1");
654          }
655          buffer.append(" ").append(bundle.getString("ROLE_ROLEDEFINED"));
656       }
657       else
658       {
659          buffer.append(bundle.getString("ROLE_THEREARE")).append(" ");
660          buffer.append(nbRoles);
661          buffer.append(" ").append(bundle.getString("ROLE_ROLESDEFINED"));
662       }
663       return buffer.toString();
664    }
665
666    /**
667     * This is a helper method extracted from the userPortlet that returns the user's fullname.
668     *
669     * @param bundle
670     * @param user
671     * @return
672     */

673    private String JavaDoc getFullName(ResourceBundle JavaDoc bundle,
674                               User user)
675    {
676       if((user.getGivenName() != null) && (user.getGivenName().trim().length() != 0))
677       {
678          if((user.getFamilyName() != null) && (user.getFamilyName().trim().length() != 0))
679          {
680             return user.getGivenName() + " " + user.getFamilyName();
681          }
682          else
683          {
684             return user.getGivenName().trim();
685          }
686       }
687       else
688       {
689          if((user.getFamilyName() != null) && (user.getFamilyName().trim().length() != 0))
690          {
691             return user.getFamilyName().trim();
692          }
693          else
694          {
695             return bundle.getString("NAMENOTAVAILABLE");
696          }
697       }
698    }
699 }
Popular Tags