UserAuditRepositoryImpl.java

package com.tradecloud.repository.useraudit;

import com.tradecloud.domain.base.utils.DateUtils;
import com.tradecloud.domain.model.useraudit.FieldName;
import com.tradecloud.domain.useraudit.UserAudit;
import com.tradecloud.dto.useraudit.UserAuditSearch;
import com.tradecloud.repository.base.impl.CriteriaOperation;
import com.tradecloud.repository.base.impl.CriteriaValue;
import com.tradecloud.repository.base.impl.RepositoryBaseImpl;
import org.apache.log4j.Logger;
import org.hibernate.Query;
import org.hibernate.criterion.DetachedCriteria;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
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 java.util.Collection;
import java.util.LinkedHashSet;
import java.util.List;

@Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.DEFAULT)
@Repository(value = "userAuditRepository")
public class UserAuditRepositoryImpl extends RepositoryBaseImpl<UserAudit, UserAuditSearch> implements UserAuditRepository {

    private static final long serialVersionUID = 1L;

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

    public List<UserAudit> search(UserAuditSearch search) {

        DetachedCriteria criteria = DetachedCriteria.forClass(UserAudit.class);

        addSearchRestrictions(criteria, search);
        if (search.getSearchMetaParams() != null) {
            //if (search.getSearchMetaParams().getOrderBy() == null) {
            criteria.addOrder(Order.desc("updated"));
            criteria.addOrder(Order.asc("customReference"));
            criteria.addOrder(Order.asc("fieldType"));
            criteria.addOrder(Order.asc("entitySection"));
            criteria.addOrder(Order.asc("fieldName"));
            //}
        } else if (search.getSearchMetaParams() == null) {
            criteria.addOrder(Order.desc("updated"));
            criteria.addOrder(Order.asc("customReference"));
            criteria.addOrder(Order.asc("fieldType"));
            criteria.addOrder(Order.asc("entitySection"));
            criteria.addOrder(Order.asc("fieldName"));
        }

        return getExecutableCriteriaList(criteria, search.getSearchMetaParams(), "reference", true);
    }

    @Override
    @Transactional(readOnly = true)
    public long countByCriteria(UserAuditSearch search) {
        long total = 0l;
        total += countUserAudit(search, UserAudit.class);
        return total;
    }

    private long countUserAudit(UserAuditSearch 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, UserAuditSearch search) {

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

        if (search.getReference() != null) {
            criteria.add(Restrictions.like("reference", LIKE + search.getReference() + LIKE));
        }
        if (search.getCustomReference() != null) {
            criteria.add(Restrictions.like("customReference", LIKE + search.getCustomReference() + LIKE));
        }
        if (search.getFieldType() != null) {
            criteria.add(Restrictions.eq("fieldType", search.getFieldType()));
        }
        if (search.getEntitySection() != null) {
            criteria.add(Restrictions.eq("entitySection", search.getEntitySection()));
        }
        if (search.getFieldName() != null) {
            criteria.add(Restrictions.eq("fieldName", search.getFieldName()));
        }
        if (search.getCreatedFrom() != null) {
            criteria.add(Restrictions.ge("created", DateUtils.getStartOfDay(search.getCreatedFrom())));
        }
        if (search.getCreatedTo() != null) {
            criteria.add(Restrictions.le("created", DateUtils.getEndOfDay(search.getCreatedTo())));
        }
        if (search.getFirstName() != null) {
            criteria.add(Restrictions.ilike("firstName", search.getFirstName(), MatchMode.ANYWHERE));
        }
        if (search.getLastName() != null) {
            criteria.add(Restrictions.ilike("lastName", search.getLastName(), MatchMode.ANYWHERE));
        }
        if (search.getEntityId() != null) {
            criteria.add(Restrictions.eq("entityId", search.getEntityId()));
        }
        if (search.getReviewed() != null) {
            criteria.add(Restrictions.eq("reviewed", search.getReviewed()));
        }
    }

    @Override
    protected Collection<CriteriaValue> mapFieldsToValues(UserAuditSearch search) {
        log.debug("mapFieldsToValues " + search.toString());
        Collection<CriteriaValue> fields = new LinkedHashSet<CriteriaValue>();
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "reference", search.getReference()));
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "customReference", search.getCustomReference()));
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "fieldType", search.getFieldType()));
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "entitySection", search.getEntitySection()));
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "fieldName", search.getFieldName()));
        fields.add(new CriteriaValue(CriteriaOperation.GREATER_THAN, "created", search.getCreatedFrom()));
        fields.add(new CriteriaValue(CriteriaOperation.LESS_THAN, "created", search.getCreatedTo()));
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "firstName", search.getFirstName()));
        fields.add(new CriteriaValue(CriteriaOperation.EQUALS, "lastName", search.getLastName()));

        return fields;
    }

    @Override
    @Transactional(readOnly = true)
    public List<UserAudit> findUserHistory() {
        return getHibernateTemplate().loadAll(UserAudit.class);
    }

    @Override
    @Transactional(readOnly = true)
    public List<UserAudit> searchSpecificUserAudits(String reference) {
        String queryString = "from UserAudit where reference = :reference order by customReference, fieldType, entitySection, " +
                "fieldName, updated desc";
        Query query = getCurrentSession().createQuery(queryString);
        query.setParameter("reference", reference);
        return query.list();
    }

    @Override
    @Transactional(readOnly = true)
    public List<UserAudit> searchSpecificUserAuditsAndFieldNames(String reference, FieldName fieldName) {
        String queryString = "from UserAudit where reference = :reference and fieldName = :fieldName order by customReference, fieldType, " +
                "entitySection, " +
                "fieldName, updated" +
                " desc";
        Query query = getCurrentSession().createQuery(queryString);
        query.setParameter("reference", reference);
        query.setParameter("fieldName", fieldName);
        return query.list();
    }
}