// 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.technical.Dates;
  import fr.ifremer.quadrige2.core.exception.BadUpdateDtException;
  import fr.ifremer.quadrige2.core.vo.system.rule.RuleParameterVO;
  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 java.sql.Timestamp;
  import java.util.Collection;
  import java.util.Objects;
  
  /**
   * @see RuleParameter
   */
  @Repository("ruleParameterDao")
  @Lazy
  public class RuleParameterDaoImpl
      extends RuleParameterDaoBase
  {
      /**
       * Constructor used by Spring
       */
  	@Autowired
  	public RuleParameterDaoImpl(SessionFactory sessionFactory) {
  		super();
  		setSessionFactory(sessionFactory);
  	}
  
      /**
       * {@inheritDoc}
       */
      protected RuleParameterVO handleSave(RuleParameterVO source, Timestamp updateDt) {
          Preconditions.checkNotNull(source);
          Preconditions.checkNotNull(source.getRuleCd());
  
          // Load parent
          Rule parent = get(RuleImpl.class, source.getRuleCd());
  
          // Load entity
          RuleParameter entity = null;
          boolean isNew = false;
          if (source.getRuleParId() != null) {
              entity = get(source.getRuleParId());
          }
          if (entity == null) {
              entity = RuleParameter.Factory.newInstance();
              parent.addRuleParameters(entity);
              entity.setRule(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.getRuleCd(),
                              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
         ruleParameterVOToEntity(source, entity, true);
 
         // Save entity
         if (isNew) {
             getSession().save(entity);
             // Affect new Id
             source.setRuleParId(entity.getRuleParId());
         } else {
             getSession().update(entity);
         }
 
         return source;
     }
 
     /**
      * {@inheritDoc}
      */
     protected void handleRemoveByIds(Collection<Integer> ruleParIds) {
         for (Integer ruleParId: ruleParIds) {
             remove(ruleParId);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     public void toRuleParameterVO(
         RuleParameter source,
         RuleParameterVO target)
     {
         super.toRuleParameterVO(source, target);
 
         // Rule
         if (source.getRule() == null) {
             target.setRuleCd(null);
         }
             else {
             target.setRuleCd(source.getRule().getRuleCd());
         }
 
         // Function
         if (source.getFunctionParameter() == null) {
             target.setFunctionParId(null);
         }
         else {
             target.setFunctionParId(source.getFunctionParameter().getFunctionParId());
         }
 
     }
 
     /**
      * 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 RuleParameter loadRuleParameterFromRuleParameterVO(RuleParameterVO ruleParameterVO)
     {
         RuleParameter ruleParameter = null;
         if (ruleParameterVO.getRuleParId() != null) {
             ruleParameter = this.get(ruleParameterVO.getRuleParId());
         }
         if (ruleParameter == null) {
             ruleParameter = RuleParameter.Factory.newInstance();
         }
         return ruleParameter;
     }
 
     /**
      * {@inheritDoc}
      */
     public RuleParameter ruleParameterVOToEntity(RuleParameterVO ruleParameterVO)
     {
         RuleParameter entity = this.loadRuleParameterFromRuleParameterVO(ruleParameterVO);
         this.ruleParameterVOToEntity(ruleParameterVO, entity, true);
         return entity;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void ruleParameterVOToEntity(
         RuleParameterVO source,
         RuleParameter target,
         boolean copyIfNull)
     {
         super.ruleParameterVOToEntity(source, target, copyIfNull);
 
         // Id
         if (copyIfNull || source.getRuleParId() != null) {
             target.setRuleParId(source.getRuleParId());
         }
 
         // Rule
         if (copyIfNull || source.getRuleCd() != null) {
             if (source.getRuleCd() == null) {
                 target.setRule(null);
             }
             else {
                 target.setRule(load(RuleImpl.class, source.getRuleCd()));
             }
         }
 
         // Function parameter
         if (copyIfNull || source.getFunctionParId() != null) {
             if (source.getFunctionParId() == null) {
                 target.setFunctionParameter(null);
             }
             else {
                 target.setFunctionParameter(load(FunctionParameterImpl.class, source.getFunctionParId()));
             }
         }
     }
 }