/**
    * Copyright 2005-2006 the original author or authors.
    *
    * Licensed under the Gnu General Pubic License, Version 2.0 (the
    * "License"); you may not use this file except in compliance with
    * the License. You may obtain a copy of the License at
    *
    *      http://www.opensource.org/licenses/gpl-license.php
    *
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   * See the Gnu General Public License for more details.
   */
  package org.figure8.join.control.action;
  
  import org.figure8.join.control.JoinAction;
  import org.figure8.join.control.form.PermissionForm;
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.businessobjects.security.User;
  import org.figure8.join.businessobjects.security.Role;
  import org.figure8.join.businessobjects.security.Permission;
  import org.figure8.join.businessfacades.security.UserManager;
  import org.figure8.join.businessfacades.security.PermissionManager;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.struts.action.ActionForm;
  import org.apache.struts.action.ActionForward;
  import org.apache.struts.action.ActionMapping;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  
  import java.util.List;
  import java.util.Iterator;
  /**
   * Struts action set used for creating, saving and retrieving security roles
   * and permissions through Join application.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.1 $
   *
   * @struts.action path="/permission" name="permissionForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/permissions.jsp"
   * @struts.action-forward name="Roles" path="/jsp/user/roles.jsp"
   * @struts.action-forward name="Users" path="/action/user?op=search"
   * @struts.action-forward name="Permissions" path="/jsp/user/permissions.jsp"
   */
  public class PermissionActions extends JoinAction{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(PermissionActions.class);
  
     /** Operation code for loading a specific security Role. */
     public static final String LOAD_ROLE_OP = "loadRole";
     /** Operation code for saving a security Role (create or update). */
     public static final String SAVE_ROLE_OP = "saveRole";
  
     /** Operation code for loading a specific user security Permission. */
     public static final String LOAD_PERMISSIONS_OP = "loadPermissions";
     /** Operation code for saving security Permissions for a user. */
     public static final String SAVE_PERMISSIONS_OP = "savePermissions";
  
     /**
      * The session scope attribute under which the Role object currently
      * selected by our logged-in User is stored.
      */
     public static final String ROLE_KEY = "role";
     /**
      * The request scope attribute under which is stored the Role that
      * has raised a DuplicateEntityException during save of another one.
      */
     public static final String DUPLICATE_ROLE_KEY = "duplicate";
  
  
     // Attributes ---------------------------------------------------------------
  
     /** Join user manager to use. */
     private UserManager userManager = null;
     /** Join permission manager to use. */
     private PermissionManager permissionManager = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of PermissionActions. */
     public PermissionActions(){
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @param manager <code>UserManager</code> implementation instance */
     public void setUserManager(UserManager manager){
       this.userManager = manager;
    }
    /** @param manager <code>PermissionManager</code> implementation instance */
    public void setPermissionManager(PermissionManager manager){
       this.permissionManager = manager;
    }
 
 
    // Implementation of JoinAction ---------------------------------------------
 
    /**
     *
     * @param operation String representing the operation to invoke on Action
     * @param mapping Mapping between forwards name and path for this action
     * @param form The form object containing request parameters
     * @param request The servlet container request wrapper
     * @param response The servlet container response wrapper
     * @return A forward to the next view to render and display
     */
    public ActionForward doExecute(String operation, ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       // Trace operation to execute.
       log.debug("doExecute() called for '" + operation + "' operation");
 
       if (LOAD_ROLE_OP.equals(operation)){
          return loadRole(mapping, form, request, response);
       }
       else if (SAVE_ROLE_OP.equals(operation)){
          return saveRole(mapping, form, request, response);
       }
       else if (LOAD_PERMISSIONS_OP.equals(operation)){
          return loadPermissions(mapping, form, request, response);
       }
       else if (SAVE_PERMISSIONS_OP.equals(operation)){
          return savePermissions(mapping, form, request, response);
       }
       else{
          // Default : empty roles management page.
          request.getSession().removeAttribute(ROLE_KEY);
          return mapping.findForward("Roles");
       }
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Load a specified role from datastore and fill form with it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward loadRole(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof PermissionForm){
          // Get the requested role from manager.
          PermissionForm pForm = (PermissionForm)form;
          Role role = permissionManager.getRole(pForm.getId());
 
          // Store release within session.
          HttpSession session = request.getSession();
          session.setAttribute(ROLE_KEY, role);
          // Copy into form the role properties.
          PropertyUtils.copyProperties(pForm, role);
 
          // Forward.
          return mapping.findForward("Roles");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Save a role into datastore. The Role may be an already existing one
     * or a new one (this is indeed a create or update method).
     * @return A forward to the next view to render and display
     */
    protected ActionForward saveRole(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof PermissionForm){
          // Get the correct form.
          PermissionForm pForm = (PermissionForm)form;
 
          // Is there's a role to update in session ?
          HttpSession session = request.getSession();
          Role role = (Role)session.getAttribute(ROLE_KEY);
 
          // Create a new Role or populate existing with form.
          if (role == null){
             log.info("Creation of a new Role with name: " + pForm.getName());
             role = new Role(pForm.getName(), pForm.getDescription());
             // Add permission resource resolver if specified.
             if (pForm.getPermissionResourceResolverClass() != null)
                role.setPermissionResourceResolverClass(pForm.getPermissionResourceResolverClass());
          }
          else{
             log.info("Update of existing Role having name: " + role.getName());
             PropertyUtils.copyProperties(role, pForm);
          }
 
          // Save role using manager.
          try {permissionManager.saveRole(role);}
          catch (DuplicateEntityException dee){
             // Store exception within request.
             request.setAttribute(DUPLICATE_ROLE_KEY, dee.getOriginalEntity());
             return mapping.findForward("Roles");
          }
 
          // Forward depending on user presence.
          User user = (User)session.getAttribute(UserActions.USER_KEY);
          if (user != null){
             return loadPermissions(mapping, form, request, response);
          }
          
          // Remove form and session attribute if present.
          session.removeAttribute(ROLE_KEY);
          removeObsoleteForm(mapping, request);
 
          return mapping.findForward("Roles");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Load security permissions from datastore for a specified user and fill form with them.
     * @return A forward to the next view to render and display
     */
    protected ActionForward loadPermissions(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof PermissionForm){
          // Get the correct form.
          PermissionForm pForm = (PermissionForm)form;
 
          // First, look if user is in session.
          HttpSession session = request.getSession();
          User user = (User)session.getAttribute(UserActions.USER_KEY);
          // If not in session, retrieve its id from form.
          if (user == null){
             user = userManager.getUser(pForm.getUserId());
             session.setAttribute(UserActions.USER_KEY, user);
          }
 
          // Retrieve user's permissions and fill form.
          List permissions = permissionManager.getUserPermissions(user);
          for (int i=0; i < permissions.size(); i++)
             pForm.addPermission((Permission)permissions.get(i));
 
          // Forward.
          return mapping.findForward("Permissions");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Save security permissions for a specified user. This consists in removing all
     * its already existing permissions and creating new ones according to form data.
     * @return A forward to the next view to render and display
     */
    protected ActionForward savePermissions(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof PermissionForm){
          // Get the correct form.
          PermissionForm pForm = (PermissionForm)form;
 
          // First, look if user is in session.
          HttpSession session = request.getSession();
          User user = (User)session.getAttribute(UserActions.USER_KEY);
          // If not in session, forward to error page.
          if (user == null)
             return mapping.findForward("NoUserInSession");
 
          // Remove all user's permissions.
          permissionManager.removeAllUserPermissions(user);
 
          // Browse permissions assigned to user and create them.
          Iterator roles = pForm.getRoles().keySet().iterator();
          while (roles.hasNext()){
             // Get corresponding role domain object.
             String roleStr = (String)roles.next();
             Role role = permissionManager.getRole(roleStr);
 
             if (role != null){
                if ("on".equals(pForm.getMappedRole(roleStr))){
                   // Create a permission for raw role.
                   Permission rolePermission = new Permission(role, user.getLogin());
                   permissionManager.savePermission(rolePermission);
 
                   // Create permissions for each assigned resource.
                   String[] perms = pForm.getMappedResourcesAsStrings(roleStr);
                   if (perms != null && perms.length > 0){
                      for (int i=0; i<perms.length; i++){
                         String resourceId = (String)perms[i];
                         Permission resPermission = new Permission(role, user.getLogin(), resourceId);
                         permissionManager.savePermission(resPermission);
                      }
                   }
                }
             }
          }
 
          // Remove form if present.
          removeObsoleteForm(mapping, request);
 
          // Forward to page displaying users.
          return mapping.findForward("Users");
       }
       // This should not happen...
       return null;
    }
 }