com.enonic.cms.store.dao.LogEntryEntityDao.java Source code

Introduction

Here is the source code for com.enonic.cms.store.dao.LogEntryEntityDao.java

Source

/*
 * Copyright 2000-2013 Enonic AS
 * http://www.enonic.com/license
 */
package com.enonic.cms.store.dao;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import org.apache.commons.lang.StringUtils;
import org.hibernate.Query;
import org.hibernate.transform.ResultTransformer;
import org.springframework.stereotype.Repository;

import com.enonic.cms.framework.hibernate.support.SelectBuilder;

import com.enonic.cms.core.content.ContentEntity;
import com.enonic.cms.core.log.ContentLogEntrySpecification;
import com.enonic.cms.core.log.LogEntryEntity;
import com.enonic.cms.core.log.LogEntryKey;
import com.enonic.cms.core.log.LogEntrySpecification;
import com.enonic.cms.core.log.LogType;
import com.enonic.cms.core.log.Table;

@Repository("logEntryDao")
final class LogEntryEntityDao extends AbstractBaseEntityDao<LogEntryEntity> implements LogEntryDao {

    @SuppressWarnings({ "unchecked" })
    public List<LogEntryKey> findBySpecification(LogEntrySpecification specification, final String orderBy) {

        final String logEntryKeysHQL = getLogEntryKeysHQL(specification, orderBy);
        Query compiled = getHibernateTemplate().getSessionFactory().getCurrentSession()
                .createQuery(logEntryKeysHQL);

        if (specification.getDateFilter() != null) {
            compiled.setDate("dateFilter", specification.getDateFilter());
        }

        if (specification.isDateSpanSet()) {
            specification.setDateSpanParameters(compiled);
        }

        compiled.setCacheable(true);

        @SuppressWarnings({ "unchecked" })
        LogEntryResultTransformer transformer = new LogEntryResultTransformer(
                specification.isAllowDuplicateEntries());

        return transformer.transformList(compiled.list());

    }

    public LogEntryEntity findByKey(LogEntryKey key) {
        return get(LogEntryEntity.class, key);
    }

    private String getLogEntryKeysHQL(LogEntrySpecification specification, String orderBy) {

        final SelectBuilder hqlQuery = new SelectBuilder(0);

        hqlQuery.addSelect("le.key");
        hqlQuery.addSelectColumn("le.keyValue");
        hqlQuery.addSelectColumn("le.timestamp");
        hqlQuery.addFromTable(LogEntryEntity.class.getName(), "le", SelectBuilder.NO_JOIN, null);

        if (specification instanceof ContentLogEntrySpecification) {
            ContentLogEntrySpecification conSpecification = (ContentLogEntrySpecification) specification;
            if (!conSpecification.isAllowDeletedContent()) {
                applyNonDeletedContentOnlyFilter(specification, hqlQuery);
            }

        }

        applyTableTypeFilter(specification, hqlQuery);

        applyTypeFilter(specification, hqlQuery);

        applyUserFilter(specification, hqlQuery);

        applyDateFilter(specification, hqlQuery);

        applyDateSpan(specification, hqlQuery);

        String hql = hqlQuery.toString();

        if (StringUtils.isNotBlank(orderBy)) {
            hqlQuery.addOrderBy("le." + orderBy);
            hql = hqlQuery.toString();
            hql = hql + " GROUP BY ce.key";
        }

        return hql;
    }

    private void applyTableTypeFilter(LogEntrySpecification specification, SelectBuilder hqlQuery) {
        if (specification.getTableTypes() != null && specification.getTableTypes().length > 0) {

            hqlQuery.addFilter("AND",
                    "le.tableKey IN ( " + createLogTableTypeString(specification.getTableTypes()) + " )");
        }

    }

    private void applyDateFilter(LogEntrySpecification specification, SelectBuilder hqlQuery) {
        if (specification.getDateFilter() != null) {
            hqlQuery.addFilter("AND", "le.timestamp > :dateFilter");
        }

    }

    private void applyDateSpan(LogEntrySpecification specification, SelectBuilder hqlQuery) {
        if (specification.isDateSpanSet()) {
            specification.appendDateSpan("le", hqlQuery);
        }
    }

    private void applyNonDeletedContentOnlyFilter(LogEntrySpecification specification, SelectBuilder hqlQuery) {
        hqlQuery.addFromTable(ContentEntity.class.getName(), "ce", SelectBuilder.NO_JOIN, null);
        hqlQuery.addFilter("AND", "ce.key = le.keyValue");
        hqlQuery.addFilter("AND", "ce.deleted = 0");
    }

    private void applyUserFilter(LogEntrySpecification specification, SelectBuilder hqlQuery) {
        if (specification.getUser() != null) {
            hqlQuery.addFilter("AND", "le.user.key = '" + specification.getUser().getKey() + "'");
        }
    }

    private void applyTypeFilter(LogEntrySpecification specification, SelectBuilder hqlQuery) {
        if (specification.getTypes() != null && specification.getTypes().length > 0) {

            hqlQuery.addFilter("AND", "le.type IN ( " + createLogTypesString(specification.getTypes()) + " )");
        }
    }

    private String createLogTypesString(LogType[] types) {
        String typesString = "";
        for (int i = 0; i < types.length; i++) {
            typesString += types[i].asInteger();
            if ((i + 1) != types.length) {
                typesString += ",";
            }
        }
        return typesString;
    }

    private String createLogTableTypeString(Table[] tableTypes) {
        String typesString = "";
        for (int i = 0; i < tableTypes.length; i++) {
            typesString += tableTypes[i].asInteger();
            if ((i + 1) != tableTypes.length) {
                typesString += ",";
            }
        }
        return typesString;
    }

}

final class LogEntryResultTransformer implements ResultTransformer {

    private boolean allowDuplicates;

    public LogEntryResultTransformer(boolean duplicates) {
        allowDuplicates = duplicates;
    }

    @SuppressWarnings("unchecked")
    public List<LogEntryKey> transformList(List list) {

        if (!allowDuplicates) {
            return nonDuplicateEntries(list);
        }
        return duplicateEntries(list);

    }

    private List<LogEntryKey> duplicateEntries(List list) {
        List<LogEntryKey> keysList = new ArrayList<LogEntryKey>();
        for (Object object : list) {
            Object[] row = (Object[]) object;
            LogEntryKey key = (LogEntryKey) row[0];
            keysList.add(key);
        }

        return keysList;
    }

    private List<LogEntryKey> nonDuplicateEntries(List list) {
        List<LogEntryKey> distinctList = new ArrayList<LogEntryKey>();
        Set<Integer> added = new HashSet<Integer>();
        for (Object object : list) {
            Object[] row = (Object[]) object;
            LogEntryKey key = (LogEntryKey) row[0];
            Integer contentKey = (Integer) row[1];
            if (!isAlreadyAdded(contentKey, added)) {
                distinctList.add(key);
                added.add(contentKey);
            }
        }

        return distinctList;
    }

    public Object transformTuple(Object[] arg0, String[] arg1) {
        throw new IllegalStateException("Not implemented");
    }

    private boolean isAlreadyAdded(Integer key, Set<Integer> added) {
        return added.contains(key);
    }

}