HibernateEventClassDao.java

/*
 * Copyright 2014-2016 CyberVision, Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.kaaproject.kaa.server.common.dao.impl.sql;

import static org.apache.commons.lang.StringUtils.isNotBlank;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.ECFV_ALIAS;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.ECFV_PROPERTY;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.ECFV_REFERENCE;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.EVENT_CLASS_TYPE_PROPERTY;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.FQN_PROPERTY;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.TENANT_ALIAS;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.TENANT_PROPERTY;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.TENANT_REFERENCE;
import static org.kaaproject.kaa.server.common.dao.DaoConstants.VERSION_PROPERTY;

import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Restrictions;
import org.kaaproject.kaa.common.dto.event.EventClassType;
import org.kaaproject.kaa.server.common.dao.impl.EventClassDao;
import org.kaaproject.kaa.server.common.dao.model.sql.EventClass;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Repository;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;

@Repository
public class HibernateEventClassDao extends HibernateAbstractDao<EventClass>
        implements EventClassDao<EventClass> {

  private static final Logger LOG = LoggerFactory.getLogger(HibernateEventClassDao.class);

  @Override
  protected Class<EventClass> getEntityClass() {
    return EventClass.class;
  }

  @Override
  public List<EventClass> findByEcfvId(String ecfvId) {
    List<EventClass> eventClasses = Collections.emptyList();
    LOG.debug("Searching event classes by ecfv id [{}] ", ecfvId);
    if (isNotBlank(ecfvId)) {
      eventClasses = findListByCriterionWithAlias(ECFV_PROPERTY, ECFV_ALIAS, Restrictions.eq(
              ECFV_REFERENCE, Long.valueOf(ecfvId)));
    }
    if (LOG.isTraceEnabled()) {
      LOG.trace("[{}] Search result: {}.", ecfvId, Arrays.toString(eventClasses.toArray()));
    } else {
      LOG.debug("[{}] Search result: {}.", ecfvId, eventClasses.size());
    }
    return eventClasses;
  }

  @Override
  public List<EventClass> findByEcfvIdVersionAndType(String ecfvId, int version,
                                                     EventClassType type) {
    LOG.debug("Searching event class by ecfv id [{}] version [{}] and type [{}]",
            ecfvId, version, type);
    List<EventClass> eventClasses = Collections.emptyList();
    if (isNotBlank(ecfvId)) {
      List<Criterion> predicates = new ArrayList<>();
      predicates.add(Restrictions.eq(ECFV_REFERENCE, Long.valueOf(ecfvId)));
      predicates.add(Restrictions.eq(VERSION_PROPERTY, version));
      if (type != null) {
        predicates.add(Restrictions.eq(EVENT_CLASS_TYPE_PROPERTY, type));
      }
      eventClasses = findListByCriterionWithAlias(ECFV_PROPERTY, ECFV_ALIAS,
          Restrictions.and(predicates.toArray(new Criterion[]{})));
    }
    if (LOG.isTraceEnabled()) {
      LOG.trace("[{},{},{}] Search result: {}.", ecfvId, version, type,
              Arrays.toString(eventClasses.toArray()));
    } else {
      LOG.debug("[{},{},{}] Search result: {}.", ecfvId, version, type, eventClasses.size());
    }
    return eventClasses;
  }

  @Override
  public void removeByEcfvId(String ecfvId) {
    if (isNotBlank(ecfvId)) {
      List<EventClass> eventClasses = findListByCriterionWithAlias(ECFV_PROPERTY, ECFV_ALIAS,
          Restrictions.eq(ECFV_REFERENCE, Long.valueOf(ecfvId)));
      removeList(eventClasses);
    }
    LOG.debug("Removed event class by ecfv id [{}] ", ecfvId);
  }

  @Override
  public List<EventClass> findByTenantIdAndFqn(String tenantId, String fqn) {
    LOG.debug("Searching event classes by tenant id [{}] and fqn [{}]", tenantId, fqn);
    List<EventClass> eventClasses = Collections.emptyList();
    if (isNotBlank(tenantId)) {
      eventClasses = findListByCriterionWithAlias(TENANT_PROPERTY, TENANT_ALIAS,
          Restrictions.and(
              Restrictions.eq(TENANT_REFERENCE, Long.valueOf(tenantId)),
              Restrictions.eq(FQN_PROPERTY, fqn)));
    }
    if (LOG.isTraceEnabled()) {
      LOG.trace("[{},{}] Search result: {}.", tenantId, fqn, Arrays.toString(
              eventClasses.toArray()));
    } else {
      LOG.debug("[{},{}] Search result: {}.", tenantId, fqn, eventClasses.size());
    }
    return eventClasses;
  }

  @Override
  public EventClass findByTenantIdAndFqnAndVersion(String tenantId, String fqn, int version) {
    LOG.debug("Searching event classes by tenant id [{}], fqn [{}] and version [{}]",
            tenantId, fqn, version);
    EventClass eventClass = null;
    if (isNotBlank(tenantId)) {
      eventClass = findOneByCriterionWithAlias(TENANT_PROPERTY, TENANT_ALIAS,
          Restrictions.and(
              Restrictions.eq(TENANT_REFERENCE, Long.valueOf(tenantId)),
              Restrictions.eq(FQN_PROPERTY, fqn),
              Restrictions.eq(VERSION_PROPERTY, version)
          ));
    }
    if (LOG.isTraceEnabled()) {
      LOG.trace("[{},{},{}] Search result: {}.", tenantId, fqn, version, eventClass);
    } else {
      LOG.debug("[{},{},{}] Search result: {}.", tenantId, fqn, version, eventClass != null);
    }
    return eventClass;
  }

}