// 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.system.rule;
   
   /*-
   * #%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.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.vo.system.rule.RuleParameterVO;
  import fr.ifremer.quadrige2.core.vo.system.rule.RulePmfmVO;
  import fr.ifremer.quadrige2.core.vo.system.rule.RuleVO;
  import org.apache.commons.collections4.CollectionUtils;
  import org.apache.commons.collections4.MapUtils;
  import org.apache.commons.lang3.ArrayUtils;
  import org.hibernate.SessionFactory;
  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.Map;
  import java.util.Objects;
  
  /**
   * @see Rule
   */
  @Repository("ruleDao")
  @Lazy
  public class RuleDaoImpl
      extends RuleDaoBase
  {
  
      @Resource
      private RuleParameterDao ruleParameterDao;
  
      @Resource
      private RulePmfmDao rulePmfmDao;
  
      @Resource(name = "deletedItemHistoryDao")
      private DeletedItemHistoryExtendDao deletedItemHistoryDao;
  
      /**
       * Constructor used by Spring
       */
  	@Autowired
  	public RuleDaoImpl(SessionFactory sessionFactory) {
  		super();
  		setSessionFactory(sessionFactory);
  	}
  
      /** {@inheritDoc} */
      @Override
      public void remove(Collection<Rule> entities) {
          Preconditions.checkNotNull(entities);
          Preconditions.checkArgument(entities.size() > 0);
  
          for (Rule entity : entities) {
              remove(entity);
          }
      }
  
      /** {@inheritDoc} */
      @Override
      public void remove(Rule entity) {
  
          // Remove rule parameters
          if (CollectionUtils.isNotEmpty(entity.getRuleParameters())) {
              ruleParameterDao.remove(entity.getRuleParameters());
              entity.getRuleParameters().clear();
         }
 
         getSession().flush();
 
         // Remove rule pmfm
         if (CollectionUtils.isNotEmpty(entity.getRulePmfms())) {
             rulePmfmDao.remove(entity.getRulePmfms());
             entity.getRulePmfms().clear();
         }
 
         getSession().flush();
 
         // Insert into DeleteItemHistory
         deletedItemHistoryDao.insertDeletedItem(RuleImpl.class, entity);
 
         super.remove(entity);
     }
 
     /**
      * {@inheritDoc}
      */
     protected RuleVO handleSave(RuleVO source, Timestamp updateDt) {
         Preconditions.checkNotNull(source);
         Preconditions.checkNotNull(source.getRuleCd());
 
         // Load parent
         RuleList parent = get(RuleListImpl.class, source.getRuleListCd());
 
         // Load entity
         Rule entity = get(source.getRuleCd());
         boolean isNew = false;
         if (entity == null) {
             entity = Rule.Factory.newInstance();
             parent.addRules(entity);
             entity.setRuleList(parent);
             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.rule.badUpdateDt", source.getRuleListCd(),
                             serverUpdateDtNoMillisecond,
                             "null"));
                 }
                 Timestamp sourceUpdateDtNoMillisecond = Dates.resetMillisecond(source.getUpdateDt());
                 if (!Objects.equals(sourceUpdateDtNoMillisecond, serverUpdateDtNoMillisecond)) {
                     throw new BadUpdateDtException(I18n.t("quadrige2.dao.rule.badUpdateDt", source.getRuleCd(), serverUpdateDtNoMillisecond,
                             sourceUpdateDtNoMillisecond));
                 }
             }
         }
 
         // update update_dt
         Timestamp newUpdateDt = updateDt;
         if (newUpdateDt == null) {
             newUpdateDt = getDatabaseCurrentTimestamp();
         }
         source.setUpdateDt(newUpdateDt);
 
         // VO -> Entity
         ruleVOToEntity(source, entity, true, false /*children not need*/);
 
         // Save entity
         if (isNew) {
             getSession().save(entity);
         } else {
             getSession().update(entity);
         }
 
         // Keep trace of items to remove
         Map<Integer, RuleParameter> ruleParametersToRemove = Beans.splitByProperty(entity.getRuleParameters(), "ruleParId");
         Map<Integer, RulePmfm> rulePmfmsToRemove = Beans.splitByProperty(entity.getRulePmfms(), "rulePmfmId");
 
         // Save rule parameters
         if (ArrayUtils.isNotEmpty(source.getRuleParameterVOs())) {
             for (RuleParameterVO ruleParameterVO : source.getRuleParameterVOs()) {
                 ruleParameterVO.setRuleCd(entity.getRuleCd());
                 ruleParameterVO = ruleParameterDao.save(ruleParameterVO, newUpdateDt);
                 ruleParametersToRemove.remove(ruleParameterVO.getRuleParId());
             }
         }
 
         // Save rule pmfm
         if (ArrayUtils.isNotEmpty(source.getRulePmfmVOs())) {
             for (RulePmfmVO rulePmfmVO : source.getRulePmfmVOs()) {
                 rulePmfmVO.setRuleCd(entity.getRuleCd());
                 rulePmfmVO = rulePmfmDao.save(rulePmfmVO, newUpdateDt);
                 rulePmfmsToRemove.remove(rulePmfmVO.getRulePmfmId());
             }
         }
 
         // Remove unused rule parameters
         if (MapUtils.isNotEmpty(ruleParametersToRemove)) {
             ruleParameterDao.remove(ruleParametersToRemove.values());
             entity.getRuleParameters().removeAll(ruleParametersToRemove.values());
         }
 
         // Remove unused rule pmfm
         if (MapUtils.isNotEmpty(rulePmfmsToRemove)) {
             rulePmfmDao.remove(rulePmfmsToRemove.values());
             entity.getRulePmfms().removeAll(rulePmfmsToRemove.values());
         }
 
         return source;
     }
 
     /**
      * {@inheritDoc}
      */
     protected void handleRemoveByCds(String[] ruleCds) {
         for (String ruleCd: ruleCds) {
             remove(ruleCd);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     public void toRuleVO(
         Rule source,
         RuleVO target)
     {
         // base attributes
         super.toRuleVO(source, target);
 
         // Parent
         if (source.getRuleList() == null) {
             target.setRuleListCd(null);
         }
         else {
             target.setRuleListCd(source.getRuleList().getRuleListCd());
         }
 
         // Function
         if (source.getFunction() == null) {
             target.setFunctionId(null);
         } else {
             target.setFunctionId(source.getFunction().getFunctionId());
         }
 
         // Rules parameters
         if (CollectionUtils.isEmpty(source.getRuleParameters())) {
             target.setRuleParameterVOs(null);
         }
         else {
             target.setRuleParameterVOs(ruleParameterDao.toRuleParameterVOArray(source.getRuleParameters()));
         }
 
         // Rules pmfm
         if (CollectionUtils.isEmpty(source.getRulePmfms())) {
             target.setRulePmfmVOs(null);
         }
         else {
             target.setRulePmfmVOs(rulePmfmDao.toRulePmfmVOArray(source.getRulePmfms()));
         }
     }
 
     /**
      * 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 Rule loadRuleFromRuleVO(RuleVO ruleVO)
     {
         Rule rule = null;
         if (ruleVO.getRuleCd() != null) {
             rule = this.get(ruleVO.getRuleCd());
         }
         if (rule == null)
         {
             rule = Rule.Factory.newInstance();
         }
         return rule;
     }
 
     /**
      * {@inheritDoc}
      */
     public Rule ruleVOToEntity(RuleVO ruleVO)
     {
         Rule entity = this.loadRuleFromRuleVO(ruleVO);
         this.ruleVOToEntity(ruleVO, entity, true);
         return entity;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void ruleVOToEntity(
         RuleVO source,
         Rule target,
         boolean copyIfNull)
     {
         this.ruleVOToEntity(source, target, copyIfNull, false/*withChildrenEntities*/);
     }
 
 
     /* -- protected methods -- */
 
     protected void ruleVOToEntity(
             RuleVO source,
             Rule target,
             boolean copyIfNull,
             boolean withChildrenEntities)
     {
         // Base attributes
         super.ruleVOToEntity(source, target, copyIfNull);
 
         // Code
         if (copyIfNull || source.getRuleCd() != null)
         {
             target.setRuleCd(source.getRuleCd());
         }
 
         // Rule list
         if (copyIfNull || source.getRuleListCd() != null) {
             if (source.getRuleListCd() == null) {
                 target.setRuleList(null);
             }
             else {
                 target.setRuleList(load(RuleListImpl.class, source.getRuleListCd()));
             }
         }
 
         // Function
         if (copyIfNull || source.getFunctionId() != null)
         {
             if (source.getFunctionId() == null) {
                 target.setFunction(null);
             }
             else {
                 target.setFunction(load(FunctionImpl.class, source.getFunctionId()));
             }
         }
 
         if (withChildrenEntities) {
 
             // Rules parameters
             if (copyIfNull || ArrayUtils.isNotEmpty(source.getRuleParameterVOs())) {
                 if (ArrayUtils.isEmpty(source.getRuleParameterVOs())) {
                     target.getRuleParameters().clear();
                 } else {
                     Daos.replaceEntities(target.getRuleParameters(),
                             source.getRuleParameterVOs(),
                             vo -> ruleParameterDao.ruleParameterVOToEntity(vo));
                 }
             }
 
             // Rules pmfm
             if (copyIfNull || ArrayUtils.isNotEmpty(source.getRulePmfmVOs())) {
                 if (ArrayUtils.isEmpty(source.getRulePmfmVOs())) {
                     target.getRulePmfms().clear();
                 } else {
                     Daos.replaceEntities(target.getRulePmfms(),
                             source.getRulePmfmVOs(),
                             vo -> rulePmfmDao.rulePmfmVOToEntity(vo));
                 }
             }
         }
     }
 }