cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/IdentifiableServiceBase.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.cdm.api.service;
  12
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.HashSet;
  16 import java.util.List;
  17 import java.util.Set;
  18
  19 import org.apache.log4j.Logger;
  20 import org.hibernate.criterion.Criterion;
  21 import org.springframework.beans.factory.annotation.Autowired;
  22 import org.springframework.transaction.annotation.Propagation;
  23 import org.springframework.transaction.annotation.Transactional;
  24
  25 import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
  26 import eu.etaxonomy.cdm.api.service.pager.Pager;
  27 import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
  28 import eu.etaxonomy.cdm.common.monitor.DefaultProgressMonitor;
  29 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  30 import eu.etaxonomy.cdm.model.common.CdmBase;
  31 import eu.etaxonomy.cdm.model.common.ISourceable;
  32 import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
  33 import eu.etaxonomy.cdm.model.common.IdentifiableSource;
  34 import eu.etaxonomy.cdm.model.common.LSID;
  35 import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
  36 import eu.etaxonomy.cdm.model.media.Rights;
  37 import eu.etaxonomy.cdm.model.name.NonViralName;
  38 import eu.etaxonomy.cdm.model.reference.Reference;
  39 import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
  40 import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;
  41 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  42 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  43 import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;
  44 import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
  45 import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;
  46 import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
  47 import eu.etaxonomy.cdm.strategy.match.IMatchable;
  48 import eu.etaxonomy.cdm.strategy.match.MatchException;
  49 import eu.etaxonomy.cdm.strategy.merge.IMergable;
  50 import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
  51 import eu.etaxonomy.cdm.strategy.merge.MergeException;
  52
  53 public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO extends IIdentifiableDao<T>> extends AnnotatableServiceBase<T,DAO>
  54                                                 implements IIdentifiableEntityService<T>{
  55
  56     @Autowired
  57     protected ICommonService commonService;
  58
  59
  60         protected static final int UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE = 1000;
  61         protected static final  Logger logger = Logger.getLogger(IdentifiableServiceBase.class);
  62
  63         @Transactional(readOnly = true)
  64         public Pager<Rights> getRights(T t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
  65         Integer numberOfResults = dao.countRights(t);
  66
  67                 List<Rights> results = new ArrayList<Rights>();
  68                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
  69                         results = dao.getRights(t, pageSize, pageNumber,propertyPaths);
  70                 }
  71
  72                 return new DefaultPagerImpl<Rights>(pageNumber, numberOfResults, pageSize, results);
  73         }
  74
  75         @Transactional(readOnly = true)
  76         public Pager<IdentifiableSource> getSources(T t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
  77                  Integer numberOfResults = dao.countSources(t);
  78
  79                         List<IdentifiableSource> results = new ArrayList<IdentifiableSource>();
  80                         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
  81                                 results = dao.getSources(t, pageSize, pageNumber,propertyPaths);
  82                         }
  83
  84                         return new DefaultPagerImpl<IdentifiableSource>(pageNumber, numberOfResults, pageSize, results);
  85         }
  86
  87
  88         @Transactional(readOnly = false)
  89         public T replace(T x, T y) {
  90                 return dao.replace(x, y);
  91         }
  92         /**
  93          * FIXME Candidate for harmonization
  94          * Given that this method is strongly typed, and generic, could we not simply expose it as
  95          * List<T> findByTitle(String title) as it is somewhat less cumbersome. Admittedly, I don't
  96          * understand what is going on with the configurators etc. so maybe there is a good reason for
  97          * the design of this method.
  98          * @param title
  99          * @return
 100          */
 101         @Transactional(readOnly = true)
 102         protected List<T> findCdmObjectsByTitle(String title){
 103                 return ((IIdentifiableDao)dao).findByTitle(title);
 104         }
 105
 106         @Transactional(readOnly = true)
 107         protected List<T> findCdmObjectsByTitle(String title, Class<T> clazz){
 108                 return ((IIdentifiableDao)dao).findByTitleAndClass(title, clazz);
 109         }
 110         @Transactional(readOnly = true)
 111         protected List<T> findCdmObjectsByTitle(String title, CdmBase sessionObject){
 112                 return ((IIdentifiableDao)dao).findByTitle(title, sessionObject);
 113         }
 114
 115         /*
 116          * TODO - Migrated from CommonServiceBase
 117          *  (non-Javadoc)
 118          * @see eu.etaxonomy.cdm.api.service.ICommonService#getSourcedObjectById(java.lang.String, java.lang.String)
 119          */
 120         @Transactional(readOnly = true)
 121         public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
 122                 ISourceable result = null;
 123
 124                 List<T> list = dao.findOriginalSourceByIdInSource(idInSource, idNamespace);
 125                 if (! list.isEmpty()){
 126                         result = list.get(0);
 127                 }
 128                 return result;
 129         }
 130
 131         /* (non-Javadoc)
 132          * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache()
 133          */
 134         @Transactional(readOnly = true)
 135         public List<UuidAndTitleCache<T>> getUuidAndTitleCache() {
 136                 return dao.getUuidAndTitleCache();
 137         }
 138
 139         @Transactional(readOnly = true)
 140         public Pager<T> findByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 141                  Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
 142
 143                  List<T> results = new ArrayList<T>();
 144                  if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 145                                 results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 146                  }
 147
 148                   return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 149         }
 150
 151         @Transactional(readOnly = true)
 152         public Pager<T> findByTitle(IIdentifiableEntityServiceConfigurator<T> config){
 153                 return findByTitle(config.getClazz(), config.getTitleSearchStringSqlized(), config.getMatchMode(), config.getCriteria(), config.getPageSize(), config.getPageNumber(), config.getOrderHints(), config.getPropertyPaths());
 154         }
 155
 156         @Transactional(readOnly = true)
 157         public List<T> listByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 158                  Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
 159
 160                  List<T> results = new ArrayList<T>();
 161                  if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 162                                 results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 163                  }
 164                  return results;
 165         }
 166
 167         @Transactional(readOnly = true)
 168         public Pager<T> findTitleCache(Class<? extends T> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode){
 169                 long numberOfResults = dao.countTitleCache(clazz, queryString, matchMode);
 170
 171                  List<T> results = new ArrayList<T>();
 172                  if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 173                                 results = dao.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
 174                  }
 175                  int r = 0;
 176                  r += numberOfResults;
 177
 178                   return new DefaultPagerImpl<T>(pageNumber, r , pageSize, results);
 179         }
 180
 181         @Transactional(readOnly = true)
 182         public List<T> listByReferenceTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 183                  Integer numberOfResults = dao.countByReferenceTitle(clazz, queryString, matchmode, criteria);
 184
 185                  List<T> results = new ArrayList<T>();
 186                  if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 187                                 results = dao.findByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 188                  }
 189                  return results;
 190         }
 191
 192         @Transactional(readOnly = true)
 193         public T find(LSID lsid) {
 194                 return dao.find(lsid);
 195         }
 196
 197         @Transactional(readOnly = true)
 198         public Pager<T> search(Class<? extends T> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 199         Integer numberOfResults = dao.count(clazz,queryString);
 200
 201                 List<T> results = new ArrayList<T>();
 202                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 203                         results = dao.search(clazz,queryString, pageSize, pageNumber, orderHints, propertyPaths);
 204                 }
 205
 206                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 207         }
 208
 209
 210         /* (non-Javadoc)
 211          * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache()
 212          */
 213         @Override
 214         @Transactional(readOnly = false)
 215         public void updateTitleCache() {
 216                 updateTitleCache(null, null, null, null);
 217         }
 218
 219         @Transactional(readOnly = false)  //TODO check transactional behaviour, e.g. what happens with the session if count is very large
 220         protected void updateTitleCacheImpl(Class<? extends T> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<T> cacheStrategy, IProgressMonitor monitor) {
 221                 if (stepSize == null){
 222                         stepSize = UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE;
 223                 }
 224                 if (monitor == null){
 225                         monitor = DefaultProgressMonitor.NewInstance();
 226                 }
 227
 228                 int count = dao.count(clazz);
 229                 monitor.beginTask("update titles", count);
 230                 int worked = 0;
 231                 for(int i = 0 ; i < count ; i = i + stepSize){
 232                         // not sure if such strict ordering is necessary here, but for safety reasons I do it
 233                         ArrayList<OrderHint> orderHints = new ArrayList<OrderHint>();
 234                         orderHints.add( new OrderHint("id", OrderHint.SortOrder.ASCENDING));
 235                         List<T> list = this.list(clazz, stepSize, i, orderHints, null);
 236                         List<T> entitiesToUpdate = new ArrayList<T>();
 237                         for (T entity : list){
 238                                 if (entity.isProtectedTitleCache() == false){
 239                                         updateTitleCacheForSingleEntity(cacheStrategy, entitiesToUpdate, entity);
 240                                 }
 241                                 worked++;
 242                         }
 243                         for (T entity: entitiesToUpdate){
 244                                 if (entity.getTitleCache() != null){
 245                                         //System.err.println(entity.getTitleCache());
 246                                 }else{
 247                                         //System.err.println("no titleCache" + ((NonViralName)entity).getNameCache());
 248                                 }
 249                         }
 250                         saveOrUpdate(entitiesToUpdate);
 251                         monitor.worked(list.size());
 252                         if (monitor.isCanceled()){
 253                                 monitor.done();
 254                                 return;
 255                         }
 256                 }
 257                 monitor.done();
 258         }
 259
 260         /**
 261          * @param cacheStrategy
 262          * @param entitiesToUpdate
 263          * @param entity
 264          */
 265         /**
 266          * @param cacheStrategy
 267          * @param entitiesToUpdate
 268          * @param entity
 269          */
 270         private void updateTitleCacheForSingleEntity(
 271                         IIdentifiableEntityCacheStrategy<T> cacheStrategy,
 272                         List<T> entitiesToUpdate, T entity) {
 273
 274                 assert (entity.isProtectedTitleCache() == false );
 275
 276                 //exclude recursive inreferences
 277                 if (entity.isInstanceOf(Reference.class)){
 278                         Reference<?> ref = CdmBase.deproxy(entity, Reference.class);
 279                         if (ref.getInReference() != null && ref.getInReference().equals(ref)){
 280                                 return;
 281                         }
 282                 }
 283
 284
 285                 //define the correct cache strategy
 286                 IIdentifiableEntityCacheStrategy entityCacheStrategy = cacheStrategy;
 287                 if (entityCacheStrategy == null){
 288                         entityCacheStrategy = entity.getCacheStrategy();
 289                         //FIXME find out why the wrong cache strategy is loaded here, see #1876
 290                         if (entity instanceof Reference){
 291                                 entityCacheStrategy = ReferenceFactory.newReference(((Reference)entity).getType()).getCacheStrategy();
 292                         }
 293                 }
 294                 entity.setCacheStrategy(entityCacheStrategy);
 295
 296
 297                 //old titleCache
 298                 entity.setProtectedTitleCache(true);
 299                 String oldTitleCache = entity.getTitleCache();
 300                 entity.setProtectedTitleCache(false);
 301
 302                 //NonViralNames have more caches //TODO handle in NameService
 303                 String oldNameCache = null;
 304                 String oldFullTitleCache = null;
 305                 if (entity instanceof NonViralName ){
 306                         NonViralName<?> nvn = (NonViralName) entity;
 307                         if (!nvn.isProtectedNameCache()){
 308                                 nvn.setProtectedNameCache(true);
 309                                 oldNameCache = nvn.getNameCache();
 310                                 nvn.setProtectedNameCache(false);
 311                         }
 312                         if (!nvn.isProtectedFullTitleCache()){
 313                                 nvn.setProtectedFullTitleCache(true);
 314                                 oldFullTitleCache = nvn.getFullTitleCache();
 315                                 nvn.setProtectedFullTitleCache(false);
 316                         }
 317                 }
 318                 setOtherCachesNull(entity); //TODO find better solution
 319
 320                 String newTitleCache = entityCacheStrategy.getTitleCache(entity);
 321                 if (oldTitleCache == null || oldTitleCache != null && ! oldTitleCache.equals(newTitleCache) ){
 322                         entity.setTitleCache(null, false);
 323                         entity.getTitleCache();
 324                         if (entity instanceof NonViralName){
 325                                 NonViralName<?> nvn = (NonViralName) entity;
 326                                 nvn.getNameCache();
 327                                 nvn.getFullTitleCache();
 328                         }
 329                         entitiesToUpdate.add(entity);
 330                 }else if (entity instanceof NonViralName){
 331                         NonViralName<?> nvn = (NonViralName) entity;
 332                         String newnameCache = nvn.getNameCache();
 333                         String newFullTitleCache = nvn.getFullTitleCache();
 334                         if (oldNameCache == null || (oldNameCache != null && !oldNameCache.equals(newnameCache))){
 335                                 entitiesToUpdate.add(entity);
 336                         }else if (oldFullTitleCache == null || (oldFullTitleCache != null && !oldFullTitleCache.equals(newFullTitleCache))){
 337                                 entitiesToUpdate.add(entity);
 338                         }
 339                 }
 340         }
 341
 342
 343
 344         /**
 345          * Needs override if not only the title cache should be set to null to
 346          * generate the correct new title cache
 347          */
 348         protected void setOtherCachesNull(T entity) {
 349                 return;
 350         }
 351
 352
 353
 354         private class DeduplicateState{
 355                 String lastTitleCache;
 356                 Integer pageSize = 50;
 357                 int nPages = 3;
 358                 int startPage = 0;
 359                 boolean isCompleted = false;
 360                 int result;
 361         }
 362
 363         /* (non-Javadoc)
 364          * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy)
 365          */
 366         @Override
 367         @Transactional(readOnly = false)
 368         public int deduplicate(Class<? extends T> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 369                 DeduplicateState dedupState = new DeduplicateState();
 370
 371                 if (clazz == null){
 372                         logger.warn("Deduplication clazz must not be null!");
 373                         return 0;
 374                 }
 375                 if (! ( IMatchable.class.isAssignableFrom(clazz) && IMergable.class.isAssignableFrom(clazz) )  ){
 376                         logger.warn("Deduplication implemented only for classes implementing IMatchable and IMergeable. No deduplication performed!");
 377                         return 0;
 378                 }
 379                 Class matchableClass = clazz;
 380                 if (matchStrategy == null){
 381                         matchStrategy = DefaultMatchStrategy.NewInstance(matchableClass);
 382                 }
 383                 List<T> nextGroup = new ArrayList<T>();
 384
 385                 int result = 0;
 386 //              double countTotal = count(clazz);
 387 //
 388 //              Number countPagesN = Math.ceil(countTotal/dedupState.pageSize.doubleValue()) ;
 389 //              int countPages = countPagesN.intValue();
 390 //
 391
 392                 List<OrderHint> orderHints = Arrays.asList(new OrderHint[]{new OrderHint("titleCache", SortOrder.ASCENDING)});
 393
 394                 while (! dedupState.isCompleted){
 395                         //get x page sizes
 396                         List<T> objectList = getPages(clazz, dedupState, orderHints);
 397                         //after each page check if any changes took place
 398                         int nUnEqualPages = handleAllPages(objectList, dedupState, nextGroup, matchStrategy, mergeStrategy);
 399                         nUnEqualPages = nUnEqualPages + dedupState.pageSize * dedupState.startPage;
 400                         //refresh start page counter
 401                         int finishedPages = nUnEqualPages / dedupState.pageSize;
 402                         dedupState.startPage = finishedPages;
 403                 }
 404
 405                 result += handleLastGroup(nextGroup, matchStrategy, mergeStrategy);
 406                 return result;
 407         }
 408
 409
 410         private int handleAllPages(List<T> objectList, DeduplicateState dedupState, List<T> nextGroup, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 411                 int nUnEqual = 0;
 412                 for (T object : objectList){
 413                         String currentTitleCache = object.getTitleCache();
 414                         if (currentTitleCache != null && currentTitleCache.equals(dedupState.lastTitleCache)){
 415                                 //=titleCache
 416                                 nextGroup.add(object);
 417                         }else{
 418                                 //<> titleCache
 419                                 dedupState.result += handleLastGroup(nextGroup, matchStrategy, mergeStrategy);
 420                                 nextGroup = new ArrayList<T>();
 421                                 nextGroup.add(object);
 422                                 nUnEqual++;
 423                         }
 424                         dedupState.lastTitleCache = currentTitleCache;
 425                 }
 426                 handleLastGroup(nextGroup, matchStrategy, mergeStrategy);
 427                 return nUnEqual;
 428         }
 429
 430         private List<T> getPages(Class<? extends T> clazz, DeduplicateState dedupState, List<OrderHint> orderHints) {
 431                 List<T> result = new ArrayList<T>();
 432                 for (int pageNo = dedupState.startPage; pageNo < dedupState.startPage + dedupState.nPages; pageNo++){
 433                         List<T> objectList = listByTitle(clazz, null, null, null, dedupState.pageSize, pageNo, orderHints, null);
 434                         result.addAll(objectList);
 435                 }
 436                 if (result.size()< dedupState.nPages * dedupState.pageSize ){
 437                         dedupState.isCompleted = true;
 438                 }
 439                 return result;
 440         }
 441
 442         private int handleLastGroup(List<T> group, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 443                 int result = 0;
 444                 int size = group.size();
 445                 Set<Integer> exclude = new HashSet<Integer>();  //set to collect all objects, that have been merged already
 446                 for (int i = 0; i < size - 1; i++){
 447                         if (exclude.contains(i)){
 448                                 continue;
 449                         }
 450                         for (int j = i + 1; j < size; j++){
 451                                 if (exclude.contains(j)){
 452                                         continue;
 453                                 }
 454                                 T firstObject = group.get(i);
 455                                 T secondObject = group.get(j);
 456
 457                                 try {
 458                                         if (matchStrategy.invoke((IMatchable)firstObject, (IMatchable)secondObject)){
 459                                                 commonService.merge((IMergable)firstObject, (IMergable)secondObject, mergeStrategy);
 460                                                 exclude.add(j);
 461                                                 result++;
 462                                         }
 463                                 } catch (MatchException e) {
 464                                         logger.warn("MatchException when trying to match " + firstObject.getTitleCache());
 465                                         e.printStackTrace();
 466                                 } catch (MergeException e) {
 467                                         logger.warn("MergeException when trying to merge " + firstObject.getTitleCache());
 468                                         e.printStackTrace();
 469                                 }
 470                         }
 471                 }
 472                 return result;
 473         }
 474
 475          public Integer countByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria){
 476                  Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
 477
 478                  return numberOfResults;
 479          }
 480
 481         @Transactional(readOnly = true)
 482         public Integer countByTitle(IIdentifiableEntityServiceConfigurator<T> config){
 483                 return countByTitle(config.getClazz(), config.getTitleSearchStringSqlized(),
 484                                 config.getMatchMode(), config.getCriteria());
 485
 486         }
 487
 488 }
 489