X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/a13c5f660e612247367698f15186260a25a10650..7f3d97b0d181b0da0d8551587a2091d765b2f62c:/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/IdentifiableServiceBase.java

diff --git a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/IdentifiableServiceBase.java b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/IdentifiableServiceBase.java
index 69619f100b..010f9c209c 100644
--- a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/IdentifiableServiceBase.java
+++ b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/IdentifiableServiceBase.java
@@ -12,14 +12,14 @@ package eu.etaxonomy.cdm.api.service;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 import org.apache.log4j.Logger;
 import org.hibernate.criterion.Criterion;
-import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.transaction.annotation.Propagation;
 import org.springframework.transaction.annotation.Transactional;
 
 import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
@@ -38,6 +38,8 @@ import eu.etaxonomy.cdm.model.name.NonViralName;
 import eu.etaxonomy.cdm.model.reference.Reference;
 import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
 import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;
+import eu.etaxonomy.cdm.persistence.dao.hibernate.HibernateBeanInitializer;
+import eu.etaxonomy.cdm.persistence.dao.initializer.AutoPropertyInitializer;
 import eu.etaxonomy.cdm.persistence.query.MatchMode;
 import eu.etaxonomy.cdm.persistence.query.OrderHint;
 import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;
@@ -53,8 +55,8 @@ import eu.etaxonomy.cdm.strategy.merge.MergeException;
 public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO extends IIdentifiableDao<T>> extends AnnotatableServiceBase<T,DAO> 
 						implements IIdentifiableEntityService<T>{
 	
-    @Autowired
-    protected ICommonService commonService;
+//    @Autowired
+//    protected ICommonService commonService;
 
 	
 	protected static final int UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE = 1000;
@@ -217,7 +219,7 @@ public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO e
 	}
 	
 	@Transactional(readOnly = false)  //TODO check transactional behaviour, e.g. what happens with the session if count is very large 
-	protected void updateTitleCacheImpl(Class<? extends T> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<T> cacheStrategy, IProgressMonitor monitor) {
+	protected <S extends T > void updateTitleCacheImpl(Class<S> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<T> cacheStrategy, IProgressMonitor monitor) {
 		if (stepSize == null){
 			stepSize = UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE;
 		}
@@ -232,7 +234,12 @@ public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO e
 			// not sure if such strict ordering is necessary here, but for safety reasons I do it
 			ArrayList<OrderHint> orderHints = new ArrayList<OrderHint>();
 			orderHints.add( new OrderHint("id", OrderHint.SortOrder.ASCENDING));
-			List<T> list = this.list(clazz, stepSize, i, orderHints, null);
+			
+			
+			Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> oldAutoInit = switchOfAutoinitializer();
+			List<S> list = this.list(clazz, stepSize, i, orderHints, null);
+			switchOnOldAutoInitializer(oldAutoInit);
+			
 			List<T> entitiesToUpdate = new ArrayList<T>();
 			for (T entity : list){
 				if (entity.isProtectedTitleCache() == false){
@@ -257,6 +264,31 @@ public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO e
 		monitor.done();
 	}
 
+	/**
+	 * Brings back all auto initializers to the bean initializer
+	 * @see #switchOfAutoinitializer()
+	 * @param oldAutoInit
+	 */
+	protected void switchOnOldAutoInitializer(
+			Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> oldAutoInit) {
+		HibernateBeanInitializer initializer = (HibernateBeanInitializer)this.appContext.getBean("defaultBeanInitializer");
+		initializer.setBeanAutoInitializers(oldAutoInit);
+	}
+
+	/**
+	 * Removes all auto initializers from the bean initializer
+	 * 
+	 * @see #switchOnOldAutoInitializer(Map)
+	 * @return 
+	 */
+	protected Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> switchOfAutoinitializer() {
+		HibernateBeanInitializer initializer = (HibernateBeanInitializer)this.appContext.getBean("defaultBeanInitializer");
+		Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> oldAutoInitializers = initializer.getBeanAutoInitializers();
+		Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> map = new HashMap<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>>();
+		initializer.setBeanAutoInitializers(map);
+		return oldAutoInitializers;
+	}
+
 	/**
 	 * @param cacheStrategy
 	 * @param entitiesToUpdate
@@ -297,11 +329,12 @@ public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO e
 		//old titleCache
 		entity.setProtectedTitleCache(true);
 		String oldTitleCache = entity.getTitleCache();
-		entity.setProtectedTitleCache(false);
+		entity.setTitleCache(oldTitleCache, false);   //before we had entity.setProtectedTitleCache(false) but this deleted the titleCache itself
 		
-		//NonViralNames have more caches //TODO handle in NameService
+		//NonViralNames and Reference have more caches //TODO handle in NameService
 		String oldNameCache = null;
 		String oldFullTitleCache = null;
+		String oldAbbrevTitleCache = null;
 		if (entity instanceof NonViralName ){
 			NonViralName<?> nvn = (NonViralName) entity;
 			if (!nvn.isProtectedNameCache()){
@@ -314,28 +347,51 @@ public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO e
 				oldFullTitleCache = nvn.getFullTitleCache();
 				nvn.setProtectedFullTitleCache(false);
 			}
+		}else if (entity instanceof Reference){
+			Reference<?> ref = (Reference<?>) entity;
+			if (!ref.isProtectedAbbrevTitleCache()){
+				ref.setProtectedAbbrevTitleCache(true);
+				oldAbbrevTitleCache = ref.getAbbrevTitleCache();
+				ref.setProtectedAbbrevTitleCache(false);
+			}
 		}
 		setOtherCachesNull(entity); //TODO find better solution
 		
 		String newTitleCache = entityCacheStrategy.getTitleCache(entity);
 		if (oldTitleCache == null || oldTitleCache != null && ! oldTitleCache.equals(newTitleCache) ){
 			entity.setTitleCache(null, false);
-			entity.getTitleCache();
+			String newCache = entity.getTitleCache();
+			if (newCache == null){
+				logger.warn("newCache should never be null");
+			}
+			if (oldTitleCache == null){
+				logger.info("oldTitleCache should never be null");
+			}
 			if (entity instanceof NonViralName){
 				NonViralName<?> nvn = (NonViralName) entity;
 				nvn.getNameCache();
 				nvn.getFullTitleCache();
 			}
+			if (entity instanceof Reference){
+				Reference<?> ref = (Reference<?>) entity;
+				ref.getAbbrevTitleCache();
+			}
 			entitiesToUpdate.add(entity);
 		}else if (entity instanceof NonViralName){
 			NonViralName<?> nvn = (NonViralName) entity;
-			String newnameCache = nvn.getNameCache();
+			String newNameCache = nvn.getNameCache();
 			String newFullTitleCache = nvn.getFullTitleCache();
-			if (oldNameCache == null || (oldNameCache != null && !oldNameCache.equals(newnameCache))){
+			if (oldNameCache == null || (oldNameCache != null && !oldNameCache.equals(newNameCache))){
 				entitiesToUpdate.add(entity);
 			}else if (oldFullTitleCache == null || (oldFullTitleCache != null && !oldFullTitleCache.equals(newFullTitleCache))){
 				entitiesToUpdate.add(entity);
 			}
+		}else if (entity instanceof Reference){
+			Reference<?> ref = (Reference<?>) entity;
+			String newAbbrevTitleCache = ref.getAbbrevTitleCache();
+			if (oldAbbrevTitleCache == null || (oldAbbrevTitleCache != null && !oldAbbrevTitleCache.equals(newAbbrevTitleCache))){
+				entitiesToUpdate.add(entity);
+			}
 		}
 	}
 	
@@ -364,7 +420,7 @@ public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO e
 	 * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy)
 	 */
 	@Override
-	@Transactional(propagation = Propagation.SUPPORTS, readOnly = false)
+	@Transactional(readOnly = false)
 	public int deduplicate(Class<? extends T> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 		DeduplicateState dedupState = new DeduplicateState();
 		
@@ -484,6 +540,9 @@ public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO e
 				config.getMatchMode(), config.getCriteria());
 		
 	}
+	
+	
+
 
 }