EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

package eu.etaxonomy.cdm.api.service;

import java.util.ArrayList;

import java.util.Collection;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.hibernate.LockOptions;

import org.hibernate.Session;

import org.hibernate.criterion.Criterion;

import org.springframework.context.ApplicationContext;

import org.springframework.dao.DataAccessException;

import org.springframework.transaction.annotation.Transactional;

import eu.etaxonomy.cdm.api.service.pager.Pager;

import eu.etaxonomy.cdm.api.service.pager.impl.AbstractPagerImpl;

import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;

import eu.etaxonomy.cdm.exception.UnpublishedException;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.IPublishable;

import eu.etaxonomy.cdm.persistence.dao.common.ICdmEntityDao;

import eu.etaxonomy.cdm.persistence.dao.common.Restriction;

import eu.etaxonomy.cdm.persistence.dao.hibernate.common.DaoBase;

import eu.etaxonomy.cdm.persistence.dto.MergeResult;

import eu.etaxonomy.cdm.persistence.query.Grouping;

import eu.etaxonomy.cdm.persistence.query.MatchMode;

import eu.etaxonomy.cdm.persistence.query.OrderHint;

public abstract class ServiceBase<T extends CdmBase, DAO extends ICdmEntityDao<T>>

    @SuppressWarnings("unused")

    public final static boolean NO_UNPUBLISHED = DaoBase.NO_UNPUBLISHED;  //constant for unpublished

    protected DAO dao;

    @Override

    @Transactional(readOnly = true)

    public void lock(T t, LockOptions lockOptions) {

    }

    @Override

    @Transactional(readOnly = true)

    public void refresh(T t, LockOptions lockOptions, List<String> propertyPaths) {

    }

    @Override

    @Transactional(readOnly = false)

    @Override

    @Transactional(readOnly = true)

        return Long.valueOf(dao.count(clazz)).intValue();

    }

    @Override

    @Transactional(readOnly = false)

    public DeleteResult delete(UUID persistentObjectUUID) {

        T persistentObject = dao.findByUuid(persistentObjectUUID);

    }

            T persistentObject = dao.findByUuid(persistentObjectUUID);

        }

    @Override

    public DeleteResult delete(T persistentObject) {

    		result.addDeletedObject(persistentObject);

    	} catch(DataAccessException e){

    }

    @Override

    @Transactional(readOnly = true)

    @Override

    @Transactional(readOnly = true)

        return dao.list(uuidSet, null, null, null, null);

    }

    @Override

    @Transactional(readOnly = true)

        return dao.loadList(idSet, null, null);

    }

    @Override

    public List<T> loadByIds(List<Integer> idList, List<String> propertyPaths){

        return dao.loadList(idList, null, propertyPaths);

    }

    @Override

    @Transactional(readOnly = true)

        return uuid == null ? null : dao.findByUuid(uuid);

    }

    @Override

        return uuid == null ? null : dao.findByUuidWithoutFlush(uuid);

    }

    @Override

    @Transactional(readOnly = true)

    @Override

    @Transactional(readOnly = true)

    @Override

    @Transactional(readOnly = true)

    @Override

    @Transactional(readOnly = true)

    public <S extends T> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths){

        return dao.list(type,limit, start, orderHints, propertyPaths);

    }

    @Override

    @Transactional(readOnly = true)

        return uuid == null ? null : dao.load(uuid);

    }

    @Override

    @Override

    @Override

    @Transactional(readOnly = true)

        return uuid == null ? null : dao.load(uuid, propertyPaths);

    }

    @Override

        List<T> entities = new ArrayList<>();

        for(UUID uuid : uuids) {

    @Override

    @Transactional(readOnly = false)

    @Override

    public MergeResult<T> merge(T newInstance, boolean returnTransientEntity) {

        return dao.merge(newInstance, returnTransientEntity);

    @Override

        List<T> mergedObjects = new ArrayList<T>();

    }

    public List<MergeResult<T>> merge(List<T> detachedObjects, boolean returnTransientEntity) {

        for(T obj : detachedObjects) {

            mergedObjects.add(dao.merge(obj, returnTransientEntity));

        }

    @Override

    @Transactional(readOnly = true)

    public  <S extends T> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){

        Long numberOfResults = dao.count(type);

        List<S> results = new ArrayList<>();

        pageNumber = pageNumber == null ? 0 : pageNumber;

            results = dao.list(type, pageSize, start, orderHints, propertyPaths);

        }

        return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);

    }

    @Override

    @Transactional(readOnly = true)

    public UUID refresh(T persistentObject) {

        return dao.refresh(persistentObject);

    @Override

    @Transactional(readOnly = false)

    @Override

    @Transactional(readOnly = false)

    public <S extends T> S save(S newInstance) {

        return dao.save(newInstance);

    @Override

    @Transactional(readOnly = false)

    @Override

    @Transactional(readOnly = false)

    @Override

    public void setApplicationContext(ApplicationContext appContext){

    @Override

    @Transactional(readOnly = false)

    @Override

    @Transactional(readOnly = true)

    public <S extends T> List<S> list(S example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {

        return dao.list(example, includeProperties, limit, start, orderHints, propertyPaths);

    @Override

    @Transactional(readOnly = true)

    public <S extends T> Pager<S> page(Class<S> clazz, String param, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageIndex, List<OrderHint> orderHints, List<String> propertyPaths){

        List<S> records;

        long resultSize = dao.countByParam(clazz, param, queryString, matchmode, criteria);

        return new DefaultPagerImpl<>(pageIndex, resultSize, pageSize, records);

    }

    @Transactional(readOnly = true)

    public <S extends T> Pager<S> pageByParamWithRestrictions(Class<S> clazz, String param, String queryString, MatchMode matchmode, List<Restriction<?>> restrictions, Integer pageSize, Integer pageIndex, List<OrderHint> orderHints, List<String> propertyPaths){

        List<S> records;

        long resultSize = dao.countByParamWithRestrictions(clazz, param, queryString, matchmode, restrictions);

        Pager<S> pager = new DefaultPagerImpl<>(pageIndex, resultSize, pageSize, records);

        return pager;

    @Override

    /**

        if (!(includeUnpublished || publishable.isPublish())){

            throw new UnpublishedException("Access denied. "+  message);

}