X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/a131f971191b811fa8e01ef3394d18aa66d468d1..fdf9eec2eb7b4806e1a1cdc4020db83ce65345bc:/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/ServiceBase.java diff --git a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/ServiceBase.java b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/ServiceBase.java index d9db3756aa..509535861f 100644 --- a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/ServiceBase.java +++ b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/ServiceBase.java @@ -1,92 +1,218 @@ +// $Id$ /** * Copyright (C) 2007 EDIT -* European Distributed Institute of Taxonomy +* 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 * See LICENSE.TXT at the top of this package for the full license terms. */ package eu.etaxonomy.cdm.api.service; +import java.util.ArrayList; import java.util.Collection; -import java.util.HashMap; -import java.util.Iterator; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.UUID; import org.apache.log4j.Logger; +import org.hibernate.LockMode; +import org.hibernate.Session; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; import org.springframework.transaction.annotation.Transactional; +import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException; +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl; import eu.etaxonomy.cdm.model.common.CdmBase; import eu.etaxonomy.cdm.persistence.dao.common.ICdmEntityDao; +import eu.etaxonomy.cdm.persistence.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +public abstract class ServiceBase> implements IService, ApplicationContextAware { + @SuppressWarnings("unused") + private static final Logger logger = Logger.getLogger(ServiceBase.class); -public abstract class ServiceBase implements IService, ApplicationContextAware { - static Logger logger = Logger.getLogger(ServiceBase.class); - - int flushAfterNo = 2000; - protected ApplicationContext appContext; - protected ICdmEntityDao dao; - - protected void setEntityDao(ICdmEntityDao dao){ - this.dao=dao; - } - - /* (non-Javadoc) - * @see eu.etaxonomy.cdm.api.service.Iyyy#setApplicationContext(org.springframework.context.ApplicationContext) - */ - public void setApplicationContext(ApplicationContext appContext){ - this.appContext = appContext; - } - - protected T getCdmObjectByUuid(UUID uuid){ - return dao.findByUuid(uuid); - } - - @Transactional(readOnly = false) - protected UUID saveCdmObject(T cdmObj){ - if (logger.isDebugEnabled()){logger.debug("Save cdmObj: " + (cdmObj == null? null: cdmObj.toString()));} - return dao.saveOrUpdate(cdmObj); - } - - @Transactional(readOnly = false) - protected Map saveCdmObjectAll(Collection cdmObjCollection){ - int types = cdmObjCollection.getClass().getTypeParameters().length; - if (types > 0){ - if (logger.isDebugEnabled()){logger.debug("ClassType: + " + cdmObjCollection.getClass().getTypeParameters()[0]);} - } - - Map resultMap = new HashMap(); - Iterator iterator = cdmObjCollection.iterator(); - int i = 0; - while(iterator.hasNext()){ - if ( ( (i % 5000) == 0) && (i > 0) && ( logger.isInfoEnabled()) ){logger.info("Saved " + i + " objects" );} - T cdmObj = iterator.next(); - UUID uuid = saveCdmObject(cdmObj); - if (logger.isDebugEnabled()){logger.debug("Save cdmObj: " + (cdmObj == null? null: cdmObj.toString()));} - resultMap.put(uuid, cdmObj); - i++; - if ( (i % flushAfterNo) == 0){ - logger.info("flush"); - dao.flush(); - } - } - if ( logger.isInfoEnabled() ){logger.info("Saved " + i + " objects" );} - return resultMap; - } - - @Transactional(readOnly = false) - protected UUID removeCdmObject(T cdmObj){ - if (logger.isDebugEnabled()){logger.debug("Save cdmObj: " + (cdmObj == null? null: cdmObj.toString()));} - return dao.delete(cdmObj); - } - - protected List list(int limit, int start) { - return dao.list(limit, start); - } + //flush after saving this number of objects + int flushAfterNo = 2000; + protected ApplicationContext appContext; + + protected DAO dao; + + @Override + @Transactional(readOnly = true) + public void lock(T t, LockMode lockMode) { + dao.lock(t, lockMode); + } + + @Override + @Transactional(readOnly = true) + public void refresh(T t, LockMode lockMode, List propertyPaths) { + dao.refresh(t, lockMode, propertyPaths); + } + + @Override + @Transactional(readOnly = false) + public void clear() { + dao.clear(); + } + + @Override + @Transactional(readOnly = true) + public int count(Class clazz) { + return dao.count(clazz); + } + + @Override + @Transactional(readOnly = false) + public String delete(T persistentObject) { + return dao.delete(persistentObject).toString(); + } + + @Override + @Transactional(readOnly = true) + public boolean exists(UUID uuid) { + return dao.exists(uuid); + } + + @Override + @Transactional(readOnly = true) + public List find(Set uuidSet) { + return dao.list(uuidSet, null, null, null, null); + } + + @Override + @Transactional(readOnly = true) + public List findById(Set idSet) { //can't be called find(Set) as this conflicts with find(Set group(Class clazz,Integer limit, Integer start, List groups, List propertyPaths) { + return dao.group(clazz, limit, start, groups, propertyPaths); + } + + @Override + @Transactional(readOnly = true) + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths){ + return dao.list(type,limit, start, orderHints,propertyPaths); + } + + @Override + @Transactional(readOnly = true) + public T load(UUID uuid) { + return dao.load(uuid); + } + + @Override + @Transactional(readOnly = true) + public T load(UUID uuid, List propertyPaths){ + return dao.load(uuid, propertyPaths); + } + + @Override + @Transactional(readOnly = false) + public T merge(T newInstance) { + return dao.merge(newInstance); + } + + @Override + @Transactional(readOnly = true) + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths){ + Integer numberOfResults = dao.count(type); + List results = new ArrayList(); + pageNumber = pageNumber == null ? 0 : pageNumber; + if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) + Integer start = pageSize == null ? 0 : pageSize * 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); + } + + /** + * FIXME Candidate for harmonization + * is this method used, and if so, should it be exposed in the service layer? + * it seems a bit incongruous that we use an ORM to hide the fact that there is a + * database, then expose a method that talks about "rows" . . . + */ + @Override + @Transactional(readOnly = true) + public List rows(String tableName, int limit, int start) { + return dao.rows(tableName, limit, start); + } + + @Override + @Transactional(readOnly = false) + public Map save(Collection newInstances) { + return dao.saveAll(newInstances); + } + + @Override + @Transactional(readOnly = false) + public UUID save(T newInstance) { + return dao.save(newInstance); + } + + @Override + @Transactional(readOnly = false) + public UUID saveOrUpdate(T transientObject) { + return dao.saveOrUpdate(transientObject); + } + + @Override + @Transactional(readOnly = false) + public Map saveOrUpdate(Collection transientInstances) { + return dao.saveOrUpdateAll(transientInstances); + } + + @Override + public void setApplicationContext(ApplicationContext appContext){ + this.appContext = appContext; + } + + + protected abstract void setDao(DAO dao); + + @Override + @Transactional(readOnly = false) + public UUID update(T transientObject) { + return dao.update(transientObject); + } + + @Override + @Transactional(readOnly = true) + public List list(T example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return dao.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + }