/**
    * ComponentTypeActions.java
    *
    * Created on 6 oct. 2006, 12:30:38
    */
   package org.figure8.join.control.action;
   
   import org.figure8.join.control.JoinAction;
   import org.figure8.join.control.form.ComponentTypeForm;
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.businessobjects.artifact.ComponentType;
  import org.figure8.join.businessfacades.artifact.ArtifactManager;
  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.HttpSession;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  /**
   * Struts action used for managing Component categories (types) within Join application
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.1 $
   *
   * @struts.action path="/componentType" name="componentTypeForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/componenttypes.jsp"
   * @struts.action-forward name="ComponentTypes" path="/jsp/componenttypes.jsp"
   */
  public class ComponentTypeActions extends JoinAction{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(ComponentTypeActions.class);
  
     /** Operation code for loading a specific ComponentType */
     public static final String LOAD_OP = "load";
     /** Operation code for saving a ComponentType (create or update) */
     public static final String SAVE_OP = "save";
  
     /**
      * The session scope attribute under which the ComponentType object currently
      * selected by our logged-in User is stored
      */
     public static final String COMPONENT_TYPE_KEY = "componentType";
     /**
      * The request scope attribute under which the ComponentTypes is stored
      */
     public static final String COMPONENT_TYPES_KEY = "componentTypes";
     /**
      * The request scope attribute under which is stored the ComponentType that
      * has raised a DuplicateEntityException during save of another one.
      */
     public static final String DUPLICATE_COMPONENT_TYPE_KEY = "duplicate";
  
  
     // Attributes ---------------------------------------------------------------
  
     /** Join artifact manager instance. */
     protected ArtifactManager artifactManager;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of ComponentTypeActions */
     public ComponentTypeActions(){
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @param manager <code>ArtifactManager</code> implementation instance */
     public void setArtifactManager(ArtifactManager manager){
        this.artifactManager = 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
      * @throws Exception such as InfraStructureExceptions ...
      */
     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_OP.equals(operation)){
          return loadComponentType(mapping, form, request, response);
       }
       else if (SAVE_OP.equals(operation)){
          return saveComponentType(mapping, form, request, response);
       }
       else{
          // Default : empty component types management page.
          request.setAttribute(COMPONENT_TYPES_KEY, artifactManager.getComponentTypes());
          request.getSession().removeAttribute(COMPONENT_TYPE_KEY);
          return mapping.findForward("ComponentTypes");
       }
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Load a specified component type from datastore and fill form with it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward loadComponentType(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
          throws Exception{
 
       if (form instanceof ComponentTypeForm){
          // Get the request component type from manager.
          ComponentTypeForm tForm = (ComponentTypeForm)form;
          ComponentType type = artifactManager.getComponentType(tForm.getKey());
 
          // Store type within session.
          HttpSession session = request.getSession();
          session.setAttribute(COMPONENT_TYPE_KEY, type);
          // Copy into form the type properties.
          PropertyUtils.copyProperties(tForm, type);
 
          // Forward after having refreshed component types.
          request.setAttribute(COMPONENT_TYPES_KEY, artifactManager.getComponentTypes());
          return mapping.findForward("ComponentTypes");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Save a component type into datastore. The type 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 saveComponentType(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
          throws Exception{
 
       if (form instanceof ComponentTypeForm){
          // Get the component type form.
          ComponentTypeForm tForm = (ComponentTypeForm)form;
 
          // Is there's a type to update in session ?
          HttpSession session = request.getSession();
          ComponentType type = (ComponentType)session.getAttribute(COMPONENT_TYPE_KEY);
 
          if (type == null){
             log.info("Creation of a new ComponentType with key: " + tForm.getKey());
             type = new ComponentType(tForm.getKey(), tForm.getLabel(), tForm.getKeyTemplate(), tForm.getDescription());
          }
          else{
             log.info("Update of existing ComponentType having key: " + type.getKey());
             PropertyUtils.copyProperties(type, tForm);
          }
          try {artifactManager.saveComponentType(type);}
          catch (DuplicateEntityException dee){
             // Store exception within request.
             request.setAttribute(COMPONENT_TYPES_KEY, artifactManager.getComponentTypes());
             request.setAttribute(DUPLICATE_COMPONENT_TYPE_KEY, dee.getOriginalEntity());
             return mapping.findForward("ComponentTypes");
          }
          // Remove form and session attribute if present.
          session.removeAttribute(COMPONENT_TYPE_KEY);
          removeObsoleteForm(mapping, request);
 
          // Refresh component type list and forward.
          request.setAttribute(COMPONENT_TYPES_KEY, artifactManager.getComponentTypes());
          return mapping.findForward("ComponentTypes");
       }
       // This should not happen...
       return null;
    }
 }