/**
    * 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.ComponentForm;
  import org.figure8.join.businessobjects.commons.Release;
  import org.figure8.join.businessobjects.artifact.Component;
  import org.figure8.join.businessobjects.artifact.ComponentType;
  import org.figure8.join.businessfacades.artifact.ArtifactManager;
  import org.figure8.join.businessfacades.commons.IntegrationProcessManager;
  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 java.util.List;
  /**
   * This is a Struts action for managing all the components within Join.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.1 $
   *
   * @struts.action path="/component" name="componentForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/artifact/components.jsp"
   * @struts.action-forward name="Component" path="/jsp/artifact/component.jsp"
   * @struts.action-forward name="Components" path="/jsp/artifact/components.jsp"
   */
  public class ComponentActions extends JoinAction{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(ComponentActions.class);
  
     /** Operation code for searching components using type and release */
     public static final String SEARCH_OP = "search";
     /** Operation code for getting details on a specific Component */
     public static final String DETAILS_OP = "details";
  
     /** The request scope attribute under which the Component is stored. */
     public static final String COMPONENT_KEY = "component";
     /** The request scope attribute under which the Components are stored. */
     public static final String COMPONENTS_KEY = "components";
  
  
     // Attributes ---------------------------------------------------------------
  
     /** Join artifact manager instance. */
     protected ArtifactManager artifactManager = null;
     /** The integration process manager implementation to use. */
     protected IntegrationProcessManager processManager = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of ComponentActions. */
     public ComponentActions(){
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @param manager <code>ArtifactManager</code> implementation instance */
     public void setArtifactManager(ArtifactManager manager){
        this.artifactManager = manager;
     }
     /** @param manager The integration process manager implementation to use */
     public void setIntegrationProcessManager(IntegrationProcessManager manager){
        this.processManager = 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 (SEARCH_OP.equals(operation)){
          return searchComponents(mapping, form, request, response);
       }
       else if (DETAILS_OP.equals(operation)){
          return getComponentDetails(mapping, form, request, response);
       }
       else{
          // Default : components browsing page.
          request.setAttribute(ComponentTypeActions.COMPONENT_TYPES_KEY, artifactManager.getComponentTypes());
          return mapping.findForward("Components");
       }
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Serch all the components using the type and the bound release criteria.
     * @return A forward to the next view to render and display
     */
    protected ActionForward searchComponents(ActionMapping mapping, ActionForm form,
                                             HttpServletRequest request, HttpServletResponse response) throws Exception{
       if (form instanceof ComponentForm){
          // Get the component form.
          ComponentForm cForm = (ComponentForm)form;
 
          // Retrieve the release and type of components to search for.
          Release release = processManager.getRelease(cForm.getReleaseName());
          ComponentType type = artifactManager.getComponentType(cForm.getTypeKey());
 
          // Retrieve the list and put it into request attribute.
          List components = artifactManager.getContainedComponents(type, release);
          request.setAttribute(COMPONENTS_KEY, components);
          request.setAttribute(ReleaseActions.RELEASE_KEY, release);
          request.setAttribute(ComponentTypeActions.COMPONENT_TYPE_KEY, type);
          request.setAttribute(ComponentTypeActions.COMPONENT_TYPES_KEY, artifactManager.getComponentTypes());
 
          return mapping.findForward("Components");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Get all the details onto an existing Component.
     * @return A forward to the next view to render and display
     */
    protected ActionForward getComponentDetails(ActionMapping mapping, ActionForm form,
                                                HttpServletRequest request, HttpServletResponse response)
            throws Exception{
 
       if (form instanceof ComponentForm){
          // Get the requested deliverable from manager
          ComponentForm cForm = (ComponentForm)form;
          Component component = artifactManager.getComponent(cForm.getKey());
 
          // Store component within request.
          request.setAttribute(COMPONENT_KEY, component);
          // Copy component into the form properties.
          PropertyUtils.copyProperties(cForm, component);
          // Add the release name and type as form properties.
          cForm.setReleaseName(component.getRelease().getName());
          cForm.setTypeKey(component.getComponentType().getKey());
 
          return mapping.findForward("Component");
       }
       // This should not happen...
       return null;
    }
 }