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;
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;
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;
}
@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;
}
// 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){
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
//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()){
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);
+ }
}
}
config.getMatchMode(), config.getCriteria());
}
+
+
+
}\r
BGBM BDI Projects / cdmlib.git / blobdiff