ExportPartyRepositoryImpl.java

package com.tradecloud.repository.export.impl;

import com.tradecloud.domain.base.utils.ObjectUtil;
import com.tradecloud.domain.export.CustomerCategory;
import com.tradecloud.domain.export.ExportParty;
import com.tradecloud.domain.export.ExportPartySearch;
import com.tradecloud.repository.base.impl.CriteriaOperation;
import com.tradecloud.repository.base.impl.CriteriaValue;
import com.tradecloud.repository.base.impl.RepositoryBaseImpl;
import com.tradecloud.repository.export.ExportPartyRepository;
import org.apache.log4j.Logger;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.Projections;
import org.hibernate.criterion.Restrictions;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;

@Repository(value = "exportPartyRepository")
@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
public class ExportPartyRepositoryImpl extends RepositoryBaseImpl<ExportParty, ExportPartySearch> implements ExportPartyRepository {

    private static final String LIKE = "%";

    private static final long serialVersionUID = 1L;

    private static final Logger log = Logger.getLogger(ExportPartyRepositoryImpl.class);

    @Override
    public List<ExportParty> search(ExportPartySearch search) {
        DetachedCriteria criteria = null;
        criteria = DetachedCriteria.forClass(ExportParty.class);
        addSearchRestrictions(criteria, search);
        return getExecutableCriteriaList(criteria, search.getSearchMetaParams());
    }

    @Override
    public long countByCriteria(ExportPartySearch search) {
        // hack!
        long total = 0l;
        total += countExportParty(search, ExportParty.class);
        return total;
    }

    private long countExportParty(ExportPartySearch search, Class clazz) {
        DetachedCriteria criteria = DetachedCriteria.forClass(clazz);
        addSearchRestrictions(criteria, search);

        long count = getExecutableCriteriaCount(criteria);
        log.debug("Count for Class:" + clazz.getSimpleName() + " is " + count);
        return count;
    }

    private void addSearchRestrictions(DetachedCriteria criteria, ExportPartySearch search) {

        log.debug("addSearchRestrictions " + search.toString());

        if (search.getName() != null) {
            criteria.add(Restrictions.ilike("name", LIKE + search.getName() + LIKE));
        }

        if (search.getExternalReference() != null) {
            criteria.add(Restrictions.ilike("externalReference", LIKE + search.getExternalReference() + LIKE));
        }

        if (search.getCreatedFrom() != null && search.getCreatedTo() != null) {
            criteria.add(Restrictions.between("created", search.getCreatedFrom(), search.getCreatedTo()));
        }

        if (search.isPrincipleConsignee()) {
            criteria.add(Restrictions.eq("principleConsignee", search.isPrincipleConsignee()));
        }
    }

    /**
     * A convenience method that maps each search field from
     * {@code ProductSearch} to the corresponding value from the search.
     *
     * @param search The {@code ProductSearch} whose names and values will create
     *               the map
     * @return A map of search field-name to field-value
     */
    @Override
    protected Collection<CriteriaValue> mapFieldsToValues(ExportPartySearch search) {
        log.debug("mapFieldsToValues " + search.toString());
        Collection<CriteriaValue> fields = new LinkedHashSet<CriteriaValue>();
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "name", search.getName()));
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "externalReference", search.getExternalReference()));
        fields.add(new CriteriaValue(CriteriaOperation.GREATER_THAN, "created", search.getCreatedFrom()));
        fields.add(new CriteriaValue(CriteriaOperation.LESS_THAN, "created", search.getCreatedTo()));
        return fields;
    }

    @Override
    public List<ExportParty> findExportParties() {
        //sort by
        StringBuilder hql = new StringBuilder();
        hql.append("from ExportParty e  ");
        hql.append(" order by e.externalReference asc");
        //return getHibernateTemplate().loadAll(ExportParty.class);
        Query query = getSession().createQuery(hql.toString());
        return query.list();

    }

    @Override
    public List<ExportParty> findByCustomerCategory(CustomerCategory customerCategory) {
        StringBuilder hql = new StringBuilder().append("from ExportParty e where e.customerCategory=:customerCategory ");
        Query query = getSession().createQuery(hql.toString());
        query.setParameter("customerCategory", customerCategory);
        return query.list();
    }

    @Override
    public ExportParty findByExternalReference(String externalReference) {
        return (ExportParty) ObjectUtil.first(findByNamedQueryAndNamedParam("findByExternalReference", "externalReference", externalReference));
    }

    @Override
    public ExportParty findPrincipleExportParty(ExportPartySearch exportPartySearch) {
        Criteria criteria = getSession().createCriteria(ExportParty.class);
        criteria.setProjection(Projections.projectionList().add(Projections.property("principleExportParty")));

        criteria.add(Restrictions.eq("name", exportPartySearch.getName()));
        criteria.add(Restrictions.eq("externalReference", exportPartySearch.getExternalReference()));
        return (ExportParty) criteria.uniqueResult();
    }

    @Override
    public long countConsigneeGetDutyFund() {
        org.hibernate.query.Query query = getSessionCustom().createQuery("select count(*) from ExportParty as e where " +
                "e.principleConsignee='t' and e.canGetDutyRefund='t'");
        return (long) query.uniqueResult();
    }

    @Override
    public Collection<? extends ExportParty> getAllExportPartyPrincipalConsignees() {
        CriteriaBuilder criteriaBuilder = getSession().getCriteriaBuilder();
        CriteriaQuery<ExportParty> criteriaQuery = criteriaBuilder.createQuery(ExportParty.class);
        Root<ExportParty> c = criteriaQuery.from(ExportParty.class);
        criteriaQuery = criteriaQuery.select(c).where(criteriaBuilder.equal(c.get("principleConsignee"), true));
        org.hibernate.query.Query<ExportParty> q = getSession().createQuery(criteriaQuery);
        return q.list();
    }

    @Override
    public ExportParty retrieve(Long id) {
        ExportParty retrieve = super.retrieve(id);
        return retrieve;
    }
}