/**
    * 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.businessobjects.environment.persistence;
  
  import org.figure8.join.core.persistence.HibernateObjectDao;
  import org.figure8.join.core.InfrastructureException;
  import org.figure8.join.businessobjects.commons.Status;
  import org.figure8.join.businessobjects.environment.Deployment;
  import org.figure8.join.businessobjects.environment.LogicalEnvironment;
  import org.figure8.join.businessobjects.environment.PhysicalEnvironment;
  import org.figure8.join.businessobjects.environment.EnvironmentMapping;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  
  import java.util.List;
  /**
   * Implementation of DeploymentDao using Hibernate ORM system.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   */
  public class HibernateDeploymentDao extends HibernateObjectDao implements DeploymentDao{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger */
     private static final Log log = LogUtil.getLog(HibernateDeploymentDao.class);
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of HibernateDeploymentDao */
     public HibernateDeploymentDao(){
     }
  
  
     // Implementation of DeploymentDao ------------------------------------------
  
     /**
      * Retrieve a deployment specified by its identifier
      * @param id The unique identifier of deployment to retrieve
      * @return The deployment corresponding to id or null if no deployment has this is
      */
     public Deployment getDeployment(long id){
        return (Deployment)getById(id);
     }
  
     /**
      * Retrieve the currently active deployment done using an EnvironmentMapping
      * @param mapping The mapping to get last active deployment for
      * @return The active deployment corresponding to mapping, or null if none.
      */
     public Deployment getActiveDeploymentForMapping(EnvironmentMapping mapping){
        Deployment lastActive = (Deployment)findSingleObject(findNamedQueryStringParam(
                "join.deployment_findActivesForEnvironmentMapping", "envMapping", mapping, false, 1));
        if (log.isDebugEnabled())
           log.debug("Found an active deployment for EnvironmentMapping " + mapping.getId() + " ? " + (lastActive != null ? "true" : "false"));
        return lastActive;
     }
  
     /**
      * Get all the deployments being realized at time of invocation
      * @return A list of {@link org.figure8.join.businessobjects.environment.Deployment}s
      */
     public List getRealizingDeployments(){
        List result = findNamedQuery("join.deployment_findRealizing");
        if (log.isDebugEnabled())
           log.debug("Found " + result.size() + " deployment(s) being realized now");
        return result;
     }
  
     /**
      * Get all the deployments being prepared at time of invocation
      * @return A list of {@link org.figure8.join.businessobjects.environment.Deployment}s
      */
     public List getPreparingDeployments(){
        List result = findNamedQuery("join.deployment_findPreparing");
        if (log.isDebugEnabled())
           log.debug("Found " + result.size() + " deployment(s) being prepared now");
        return result;
     }
  
     /**
      * Get all the deployments having one of the specified status
      * @param status A list of specified status
      * @param includeNull Flag telling if deployment with no status should be included
      * @return A list of {@link org.figure8.join.businessobjects.environment.Deployment}s
     */
    public List getDeploymentsHavingStatus(List status, boolean includeNull){
       List result = null;
       try{
          StringBuffer whereclause = new StringBuffer();
          // Build a In clause if we have status !
          if (status != null && !status.isEmpty()){
             StringBuffer inclause = new StringBuffer("(");
             for (int i=0; i<status.size(); i++){
                inclause.append(((Status)status.get(i)).getId());
                if (i<status.size() - 1) inclause.append(", ");
             }
             inclause.append(")");
             // Use Hibernate template to create a custom SQL query with in clause.
             whereclause.append("dep.status.id in ").append(inclause);
          }
          // Eventually complete where clause.
          if (includeNull){
             if (whereclause.length() == 0) whereclause.append("dep.status is null");
             if (whereclause.length() > 0) whereclause.append(" or dep.status is null");
          }
          result = getHibernateTemplate().find("from Deployment dep where " + whereclause);
       }
       catch (Exception e){
          // Log and wrap into runtime infrastructure exception.
          log.error("Exception into getDeploymentsHavingStatus: " + e.getMessage());
          throw new InfrastructureException("Exception while retrieving deployments with one of specified status", e);
       }
       if (log.isDebugEnabled())
          log.debug("Found " + result.size() + " deployment(s) for specified status: " + status);
       return result;
    }
 
    /**
     * Retrieve all the deployments done for a specified logical environment
     * @param logicalEnv The logical environment to get deployments for
     * @return A list of {@link org.figure8.join.businessobjects.environment.Deployment}s done for logical environment
     */
    public List getDeploymentsByLogicalEnvironment(LogicalEnvironment logicalEnv){
       List result = findNamedQueryStringParam("join.deployment_findByLogicalEnvironment", "logicalEnv", logicalEnv);
       if (log.isDebugEnabled())
          log.debug("Found " + result.size() + " deployments for logical env: " + logicalEnv.getKey());
       return result;
    }
 
    /**
     * Retrieve all the deployments done onto a specified physical environment
     * @param physicalEnv The physical environment to get deployments for
     * @return A list of {@link org.figure8.join.businessobjects.environment.Deployment}s done onto this physical environemnt
     */
    public List getDeploymentsByPhysicalEnvironment(PhysicalEnvironment physicalEnv){
       List result = findNamedQueryStringParam("join.deployment_findByPhysicalEnvironment", "physicalEnv", physicalEnv);
       if (log.isDebugEnabled())
          log.debug("Found " + result.size() + " deployments for physical env: " + physicalEnv.getKey());
       return result;
    }
 
 
    // Implementation of ObjectDao ----------------------------------------------
 
    /** @return The org.figure8.join.businessobjects.environment.Deployment class */
    public Class getPersistentClass(){
       return org.figure8.join.businessobjects.environment.Deployment.class;
    }
 }