package fr.ifremer.quadrige3.core.dao.system.rule;
   
   /*-
    * #%L
    * Quadrige3 Core :: Quadrige3 Client 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 fr.ifremer.quadrige3.core.dao.technical.Assert;
  import fr.ifremer.quadrige3.core.vo.system.rule.RuleParameterVO;
  import org.hibernate.SessionFactory;
  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;
  
  /**
   * @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) {
          Assert.notNull(source);
          Assert.notNull(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 :
          // NOT NEED on a client database
  
          // Update update_dt
          // NOT NEED on a client database
  
          // 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()));
             }
         }
     }
 }