// Generated by: hibernate/SpringHibernateDaoImpl.vsl in andromda-spring-cartridge.
   // license-header java merge-point
   /**
    * This is only generated once! It will never be overwritten.
    * You can (and have to!) safely modify it by hand.
    */
   package fr.ifremer.quadrige2.core.dao.data.survey;
   
   /*-
   * #%L
   * Quadrige2 Core :: Quadrige2 Server Core
   * %%
   * Copyright (C) 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * 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.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import com.google.common.base.Preconditions;
  import fr.ifremer.quadrige2.core.config.Quadrige2Configuration;
  import fr.ifremer.quadrige2.core.dao.administration.program.ProgramStrategyJdbcDao;
  import fr.ifremer.quadrige2.core.dao.administration.user.DepartmentImpl;
  import fr.ifremer.quadrige2.core.dao.administration.user.QuserImpl;
  import fr.ifremer.quadrige2.core.dao.system.synchronization.DeletedItemHistoryExtendDao;
  import fr.ifremer.quadrige2.core.dao.technical.Beans;
  import fr.ifremer.quadrige2.core.dao.technical.Daos;
  import fr.ifremer.quadrige2.core.dao.technical.Dates;
  import fr.ifremer.quadrige2.core.exception.BadUpdateDtException;
  import fr.ifremer.quadrige2.core.exception.DataLockedException;
  import fr.ifremer.quadrige2.core.exception.Quadrige2TechnicalException;
  import fr.ifremer.quadrige2.core.vo.data.survey.CampaignVO;
  import fr.ifremer.quadrige2.core.vo.data.survey.OccasionVO;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.lang3.ArrayUtils;
  import org.hibernate.*;
  import org.hibernate.exception.LockTimeoutException;
  import org.hibernate.type.IntegerType;
  import org.nuiton.i18n.I18n;
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.context.annotation.Lazy;
  import org.springframework.stereotype.Repository;
  
  import javax.annotation.Resource;
  import java.sql.Timestamp;
  import java.util.Collection;
  import java.util.List;
  import java.util.Objects;
  
  /**
   * @see Campaign
   */
  @Repository("campaignDao")
  @Lazy
  public class CampaignDaoImpl
          extends CampaignDaoBase {
      @Resource
      private Quadrige2Configuration config;
  
      @Resource(name = "occasionDao")
      private OccasionDao occasionDao;
  
      @Resource(name = "programStrategyJdbcDao")
      private ProgramStrategyJdbcDao programStrategyJdbcDao;
  
      @Resource(name = "deletedItemHistoryDao")
      private DeletedItemHistoryExtendDao deletedItemHistoryDao;
  
      /**
       * Constructor used by Spring
       */
      @Autowired
      public CampaignDaoImpl(SessionFactory sessionFactory) {
          super();
          setSessionFactory(sessionFactory);
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      public void remove(Collection<Campaign> entities) {
          Preconditions.checkNotNull(entities);
          Preconditions.checkArgument(entities.size() > 0);
  
          for (Campaign entity : entities) {
              remove(entity);
          }
      }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void remove(Campaign entity) {
 
         // Lock, if possible
         try {
             Session.LockRequest lockRequest = getSession().buildLockRequest(LockOptions.UPGRADE);
             lockRequest.setLockMode(LockMode.UPGRADE_NOWAIT);
             lockRequest.setScope(true); // cascaded to owned collections and relationships.
             lockRequest.lock(entity);
         } catch (LockTimeoutException e) {
             throw new DataLockedException(I18n.t("quadrige2.dao.campaign.locked", entity.getCampaignId()), e);
         }
 
         // Remove occasions
         if (CollectionUtils.isNotEmpty(entity.getOccasions())) {
             occasionDao.remove(entity.getOccasions());
             entity.getOccasions().clear();
         }
 
         getSession().flush();
 
         // Remove link to program
         if (CollectionUtils.isNotEmpty(entity.getPrograms())) {
             entity.getPrograms().clear();
         }
 
         // Remove link to moratorium
         if (CollectionUtils.isNotEmpty(entity.getMoratoria())) {
             entity.getMoratoria().clear();
         }
 
         // Insert into DeleteItemHistory
         deletedItemHistoryDao.insertDeletedItem(CampaignImpl.class, entity);
 
         super.remove(entity);
     }
 
     /**
      * {@inheritDoc}
      */
     protected CampaignVO handleSave(CampaignVO source) {
         Preconditions.checkNotNull(source.getQuserId());
         Preconditions.checkNotNull(source.getRecDepId());
         Preconditions.checkNotNull(source.getCampaignStartDt());
         Preconditions.checkNotNull(source.getCampaignNm());
 
         // Already saved
         Campaign entity = null;
         if (source.getCampaignId() != null) {
             entity = get(source.getCampaignId());
         }
 
         // Load (or create) the entity
         boolean isNew = false;
         if (entity == null) {
             entity = Campaign.Factory.newInstance();
             isNew = true;
         }
 
         // Check update_dt
         if (!isNew) {
             if (entity.getUpdateDt() != null) {
                 Timestamp serverUpdateDtNoMillisecond = Dates.resetMillisecond(entity.getUpdateDt());
                 if (source.getUpdateDt() == null) {
                     throw new BadUpdateDtException(I18n.t("quadrige2.dao.campaign.badUpdateDt", source.getCampaignId(),
                             serverUpdateDtNoMillisecond,
                             "null"));
                 }
                 Timestamp sourceUpdateDtNoMillisecond = Dates.resetMillisecond(source.getUpdateDt());
                 if (!Objects.equals(sourceUpdateDtNoMillisecond, serverUpdateDtNoMillisecond)) {
                     throw new BadUpdateDtException(I18n.t("quadrige2.dao.campaign.badUpdateDt", source.getCampaignId(), serverUpdateDtNoMillisecond,
                             sourceUpdateDtNoMillisecond));
                 }
             }
 
             // Lock, if possible
             try {
                 Session.LockRequest lockRequest = getSession().buildLockRequest(LockOptions.UPGRADE);
                 lockRequest.setLockMode(LockMode.UPGRADE_NOWAIT);
                 lockRequest.setScope(true); // cascaded to owned collections and relationships.
                 lockRequest.lock(entity);
             } catch (LockTimeoutException e) {
                 throw new DataLockedException(I18n.t("quadrige2.dao.campaign.locked", source.getCampaignId()), e);
             }
         }
 
         // Update update_dt
         Timestamp newUpdateDt = getDatabaseCurrentTimestamp();
         // Add a delay (to make sure synchro will see it, event if this transaction is long)
         newUpdateDt = Dates.addSeconds(newUpdateDt, config.getExportDataUpdateDateShortDelayInSecond());
         source.setUpdateDt(newUpdateDt);
 
         // VO -> Entity
         campaignVOToEntity(source, entity, true, false/* do not convert occasions */);
 
         // Save entity
         if (isNew) {
             Integer campaignId = (Integer) getSession().save(entity);
             source.setCampaignId(campaignId);
         } else {
             getSession().update(entity);
         }
 
         List<Integer> occasionsIdsToRemove = Beans.collectProperties(entity.getOccasions(), "occasId");
 
         // Save occasions
         if (ArrayUtils.isNotEmpty(source.getOccasionVOs())) {
             for (OccasionVO occasionVO : source.getOccasionVOs()) {
                 occasionVO.setCampaignId(entity.getCampaignId());
                 occasionVO = occasionDao.save(occasionVO, newUpdateDt);
 
                 occasionsIdsToRemove.remove(occasionVO.getOccasId());
             }
         }
 
         getSession().flush();
         getSession().clear();
 
         // remove unused occasions
         if (CollectionUtils.isNotEmpty(occasionsIdsToRemove)) {
             occasionDao.removeByIds(occasionsIdsToRemove);
         }
 
         return source;
     }
 
     @Override
     protected Long handleCountSurveyUsage(int campaignId) throws Exception {
         try
         {
             return queryCount("countSurveyUsingCampaign",
                     "campaignId", IntegerType.INSTANCE, campaignId);
 
         } catch (HibernateException he) {
             throw new Quadrige2TechnicalException(String.format("Could not get the campaign usage in surveys : %s", he.getMessage()));
         }
     }
 
     /*
     @Override
     protected Integer[] handleGetWritableCampaignIdsByUserId(Integer quserId) throws Exception {
 
         // Get writable programs for user
         List<ProgramVO> writablePrograms = programStrategyJdbcDao.getWritableProgramsByUserId(quserId);
 
         try {
 
             Query query = createQuery("writableCampaignIdsByQuserId",
                     "quserId", IntegerType.INSTANCE, quserId);
 
             // Limit to active users
             query.setParameterList("statusCodes", ImmutableList.of(StatusCode.ENABLE.getValue()));
 
             // Writable programs for user (if any)
             if (CollectionUtils.isEmpty(writablePrograms)) {
                 query.setParameter("progCds", null);
                 query.setParameter("hasProgCds", null);
             } else {
                 query.setParameterList("progCds", Lists.transform(writablePrograms, ProgramVO::getProgCd));
                 query.setParameter("hasProgCds", true);
             }
 
             List<Integer> campaignIds = (List<Integer>) query.list();
 
             return campaignIds.toArray(new Integer[campaignIds.size()]);
 
         } catch (HibernateException he) {
             throw new Quadrige2TechnicalException(String.format("Could not get the writable campaign Ids for user: %s", he.getMessage()));
         }
 
     }
 */
     /**
      * {@inheritDoc}
      */
     public void toCampaignVO(
             Campaign source,
             CampaignVO target) {
 
         // copy base attributes
         super.toCampaignVO(source, target);
 
         // copy user and recorder department attributes
         target.setQuserId(source.getQuser() != null ? source.getQuser().getQuserId() : null);
         target.setRecDepId(source.getRecorderDepartment() != null ? source.getRecorderDepartment().getDepId() : null);
 
         // Occasions
         if (CollectionUtils.isEmpty(source.getOccasions())) {
             target.setOccasionVOs(null);
         } else {
             target.setOccasionVOs(occasionDao.toOccasionVOArray(source.getOccasions()));
         }
     }
 
     /**
      * Retrieves the entity object that is associated with the specified value object
      * from the object store. If no such entity object exists in the object store,
      * a new, blank entity is created
      */
     private Campaign loadCampaignFromCampaignVO(CampaignVO campaignVO) {
 
         Campaign campaign = null;
         if (campaignVO.getCampaignId() != null) {
             campaign = get(campaignVO.getCampaignId());
         }
         if (campaign == null) {
             campaign = Campaign.Factory.newInstance();
         }
         return campaign;
     }
 
     /**
      * {@inheritDoc}
      */
     public Campaign campaignVOToEntity(CampaignVO campaignVO) {
 
         Campaign entity = this.loadCampaignFromCampaignVO(campaignVO);
         this.campaignVOToEntity(campaignVO, entity, true);
         return entity;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void campaignVOToEntity(
             CampaignVO source,
             Campaign target,
             boolean copyIfNull) {
 
         this.campaignVOToEntity(source, target, copyIfNull, false);
     }
 
     /* -- protected méthods -- */
 
     protected void campaignVOToEntity(CampaignVO source, Campaign target, boolean copyIfNull, boolean withOccasions) {
 
         // copy base attributes
         super.campaignVOToEntity(source, target, copyIfNull);
 
         // campaign id
         if (copyIfNull || source.getCampaignId() != null) {
             target.setCampaignId(source.getCampaignId());
         }
 
         // quser
         if (copyIfNull || source.getQuserId() != null) {
             target.setQuser(source.getQuserId() != null ? load(QuserImpl.class, source.getQuserId()) : null);
         }
 
         // recorder department
         if (copyIfNull || source.getRecDepId() != null) {
             target.setRecorderDepartment(source.getRecDepId() != null ? load(DepartmentImpl.class, source.getRecDepId()) : null);
         }
 
         // Strategies
         if (withOccasions)
         {
             if (copyIfNull || source.getOccasionVOs() != null) {
                 if (source.getOccasionVOs() == null) {
                     target.getOccasions().clear();
                 } else {
                     Daos.replaceEntities(target.getOccasions(),
                             source.getOccasionVOs(),
                             vo -> {
                                 Occasion occasion = occasionDao.occasionVOToEntity(vo);
                                 occasion.setCampaign(target);
                                 return occasion;
                             });
                 }
             }
         }
     }
 
 }