AppliedPeriodDaoImpl

package fr.ifremer.quadrige3.core.dao.administration.strategy;

/*-
 * #%L
 * Quadrige3 Core :: Quadrige3 Client Core
 * $Id:$
 * $HeadURL:$
 * %%
 * 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.system.synchronization.SynchronizationStatus;
import fr.ifremer.quadrige3.core.dao.technical.Assert;
import fr.ifremer.quadrige3.core.exception.SaveForbiddenException;
import fr.ifremer.quadrige3.core.vo.administration.strategy.AppliedPeriodVO;
import org.hibernate.SessionFactory;
import org.hibernate.type.DateType;
import org.hibernate.type.IntegerType;
import org.hibernate.type.StringType;
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.Collections;
import java.util.Date;

/**
 * <p>
 * AppliedPeriodDaoImpl class.
 * </p>
 *
 * @see AppliedPeriod
 */
@Repository("appliedPeriodDao")
@Lazy
public class AppliedPeriodDaoImpl
		extends AppliedPeriodDaoBase
{
	/**
	 * Constructor used by Spring
	 *
	 * @param sessionFactory
	 *            a {@link org.hibernate.SessionFactory} object.
	 */
	@Autowired
	public AppliedPeriodDaoImpl(SessionFactory sessionFactory) {
		super();
		setSessionFactory(sessionFactory);
	}

	@Override
	protected AppliedPeriodVO handleSave(AppliedPeriodVO source, Timestamp updateDt) {
		Assert.notNull(source);
		Assert.notNull(source.getAppliedPeriodStartDt());
		Assert.notNull(source.getAppliedStratId());

		AppliedPeriodPK pk = new AppliedPeriodPK();
		pk.setAppliedPeriodStartDt(source.getAppliedPeriodStartDt());
		AppliedStrategyImpl appliedStrategy = load(AppliedStrategyImpl.class, source.getAppliedStratId());
		pk.setAppliedStrategy(appliedStrategy);

		AppliedPeriod entity = this.get(pk);
		boolean isNew = false;
		if (entity == null)
		{
			entity = AppliedPeriod.Factory.newInstance();
			entity.setAppliedPeriodPk(pk);
			isNew = true;
		}

		if (!isNew) {
			// Check if this period has data outside (Mantis #48011)
			long count = queryCount("countSurveysByProgramLocationAndOutsideDates",
					"programCode", StringType.INSTANCE, appliedStrategy.getStrategy().getProgram().getProgCd(),
					"locationId", IntegerType.INSTANCE, appliedStrategy.getMonitoringLocation().getMonLocId(),
					"appliedStrategyId", IntegerType.INSTANCE, appliedStrategy.getAppliedStratId(),
					"startDate", DateType.INSTANCE, source.getAppliedPeriodStartDt(),
					"endDate", DateType.INSTANCE, source.getAppliedPeriodEndDt(),
					"synchronizationStatusToIgnore", StringType.INSTANCE, SynchronizationStatus.DELETED.getValue()
			);

			if (count > 0) {
				throw new SaveForbiddenException(SaveForbiddenException.Type.ATTACHED_DATA, "surveys outside modified period",
						Collections.singleton(appliedStrategy.getStrategy().getStratNm()));
			}
		}

		// update update_dt
		if (updateDt != null) {
			source.setUpdateDt(updateDt);
		}

		// VO -> Entity
		appliedPeriodVOToEntity(source, entity, true);

		// save entity
		if (isNew) {
			getSession().save(entity);
		} else {
			getSession().update(entity);
		}

		return source;
	}

	@Override
	protected void handleCheckCanRemove(Integer appliedStratId, String progCd, Integer monLocId, Date startDate, Date endDate) throws Exception {

		// Check if this period has data inside (Mantis #48011)
		long count = queryCount("countSurveysByProgramLocationAndInsideDates",
			"programCode", StringType.INSTANCE, progCd,
			"locationId", IntegerType.INSTANCE, monLocId,
			"appliedStrategyId", IntegerType.INSTANCE, appliedStratId,
			"startDate", DateType.INSTANCE, startDate,
			"endDate", DateType.INSTANCE, endDate,
			"synchronizationStatusToIgnore", StringType.INSTANCE, SynchronizationStatus.DELETED.getValue()
		);

		if (count > 0) {
			throw new SaveForbiddenException(SaveForbiddenException.Type.ATTACHED_DATA, "surveys inside deleted period",
				Collections.singleton(get(AppliedStrategyImpl.class, appliedStratId).getStrategy().getStratNm()));
		}

	}

	/** {@inheritDoc} */
	public void toAppliedPeriodVO(
			AppliedPeriod source,
			AppliedPeriodVO target)
	{
		super.toAppliedPeriodVO(source, target);

		AppliedPeriodPK pk = source.getAppliedPeriodPk();
		if (pk != null) {
			target.setAppliedPeriodStartDt(pk.getAppliedPeriodStartDt());
			target.setAppliedStratId(pk.getAppliedStrategy().getAppliedStratId());
		}

	}

	/**
	 * 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 AppliedPeriod loadAppliedPeriodFromAppliedPeriodVO(AppliedPeriodVO source)
	{
		AppliedPeriodPK pk = new AppliedPeriodPK();
		pk.setAppliedPeriodStartDt(source.getAppliedPeriodStartDt());
		pk.setAppliedStrategy(load(AppliedStrategyImpl.class, source.getAppliedStratId()));

		AppliedPeriod appliedPeriod = this.get(pk);
		if (appliedPeriod == null)
		{
			appliedPeriod = AppliedPeriod.Factory.newInstance();
			appliedPeriod.setAppliedPeriodPk(pk);
		}
		return appliedPeriod;
	}

	/** {@inheritDoc} */
	public AppliedPeriod appliedPeriodVOToEntity(AppliedPeriodVO appliedPeriodVO)
	{
		AppliedPeriod entity = this.loadAppliedPeriodFromAppliedPeriodVO(appliedPeriodVO);
		this.appliedPeriodVOToEntity(appliedPeriodVO, entity, true);
		return entity;
	}

	@Override
	public void remove(Collection<AppliedPeriod> entities) {
		Assert.notEmpty(entities);

		entities.forEach(this::remove);
	}
}