cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/DescriptionServiceImpl.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.Collection;
  15 import java.util.HashSet;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19 import java.util.UUID;
  20
  21 import org.apache.log4j.Logger;
  22 import org.springframework.beans.factory.annotation.Autowired;
  23 import org.springframework.stereotype.Service;
  24 import org.springframework.transaction.annotation.Transactional;
  25
  26 import eu.etaxonomy.cdm.api.service.pager.Pager;
  27 import eu.etaxonomy.cdm.api.service.pager.impl.AbstractPagerImpl;
  28 import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
  29 import eu.etaxonomy.cdm.api.utility.DescriptionUtility;
  30 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  31 import eu.etaxonomy.cdm.model.common.Annotation;
  32 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  33 import eu.etaxonomy.cdm.model.common.Language;
  34 import eu.etaxonomy.cdm.model.common.Marker;
  35 import eu.etaxonomy.cdm.model.common.MarkerType;
  36 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  37 import eu.etaxonomy.cdm.model.description.DescriptionBase;
  38 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  39 import eu.etaxonomy.cdm.model.description.Distribution;
  40 import eu.etaxonomy.cdm.model.description.Feature;
  41 import eu.etaxonomy.cdm.model.description.FeatureTree;
  42 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
  43 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  44 import eu.etaxonomy.cdm.model.description.TaxonNameDescription;
  45 import eu.etaxonomy.cdm.model.description.TextData;
  46 import eu.etaxonomy.cdm.model.location.NamedArea;
  47 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  48 import eu.etaxonomy.cdm.model.media.Media;
  49 import eu.etaxonomy.cdm.model.name.Rank;
  50 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  51 import eu.etaxonomy.cdm.model.taxon.Taxon;
  52 import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
  53 import eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao;
  54 import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionDao;
  55 import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionElementDao;
  56 import eu.etaxonomy.cdm.persistence.dao.description.IFeatureDao;
  57 import eu.etaxonomy.cdm.persistence.dao.description.IFeatureNodeDao;
  58 import eu.etaxonomy.cdm.persistence.dao.description.IFeatureTreeDao;
  59 import eu.etaxonomy.cdm.persistence.dao.description.IStatisticalMeasurementValueDao;
  60 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  61 import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
  62
  63 /**
  64  * @author a.mueller
  65  * @created 24.06.2008
  66  * @version 1.0
  67  */
  68 @Service
  69 @Transactional(readOnly = true)
  70 public class DescriptionServiceImpl extends IdentifiableServiceBase<DescriptionBase,IDescriptionDao> implements IDescriptionService {
  71
  72     private static final Logger logger = Logger.getLogger(DescriptionServiceImpl.class);
  73
  74     protected IDescriptionElementDao descriptionElementDao;
  75     protected IFeatureTreeDao featureTreeDao;
  76     protected IFeatureNodeDao featureNodeDao;
  77     protected IFeatureDao featureDao;
  78     protected ITermVocabularyDao vocabularyDao;
  79     protected IDefinedTermDao definedTermDao;
  80     protected IStatisticalMeasurementValueDao statisticalMeasurementValueDao;
  81     //TODO change to Interface
  82     private NaturalLanguageGenerator naturalLanguageGenerator;
  83
  84     @Autowired
  85     protected void setFeatureTreeDao(IFeatureTreeDao featureTreeDao) {
  86         this.featureTreeDao = featureTreeDao;
  87     }
  88
  89     @Autowired
  90     protected void setFeatureNodeDao(IFeatureNodeDao featureNodeDao) {
  91         this.featureNodeDao = featureNodeDao;
  92     }
  93
  94     @Autowired
  95     protected void setFeatureDao(IFeatureDao featureDao) {
  96         this.featureDao = featureDao;
  97     }
  98
  99     @Autowired
 100     protected void setVocabularyDao(ITermVocabularyDao vocabularyDao) {
 101         this.vocabularyDao = vocabularyDao;
 102     }
 103
 104     @Autowired
 105     protected void setDefinedTermDao(IDefinedTermDao definedTermDao) {
 106         this.definedTermDao = definedTermDao;
 107     }
 108
 109     @Autowired
 110     protected void statisticalMeasurementValueDao(IStatisticalMeasurementValueDao statisticalMeasurementValueDao) {
 111         this.statisticalMeasurementValueDao = statisticalMeasurementValueDao;
 112     }
 113
 114     @Autowired
 115     protected void setDescriptionElementDao(IDescriptionElementDao descriptionElementDao) {
 116         this.descriptionElementDao = descriptionElementDao;
 117     }
 118
 119     @Autowired
 120     protected void setNaturalLanguageGenerator(NaturalLanguageGenerator naturalLanguageGenerator) {
 121         this.naturalLanguageGenerator = naturalLanguageGenerator;
 122     }
 123
 124     /**
 125      *
 126      */
 127     public DescriptionServiceImpl() {
 128         logger.debug("Load DescriptionService Bean");
 129     }
 130
 131
 132
 133     /* (non-Javadoc)
 134      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy)
 135      */
 136     @Override
 137     @Transactional(readOnly = false)
 138     public void updateTitleCache(Class<? extends DescriptionBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<DescriptionBase> cacheStrategy, IProgressMonitor monitor) {
 139         if (clazz == null){
 140             clazz = DescriptionBase.class;
 141         }
 142         super.updateTitleCacheImpl(clazz, stepSize, cacheStrategy, monitor);
 143     }
 144
 145
 146     @Override
 147     public TermVocabulary<Feature> getDefaultFeatureVocabulary(){
 148         String uuidFeature = "b187d555-f06f-4d65-9e53-da7c93f8eaa8";
 149         UUID featureUuid = UUID.fromString(uuidFeature);
 150         return vocabularyDao.findByUuid(featureUuid);
 151     }
 152
 153     @Override
 154     @Autowired
 155     protected void setDao(IDescriptionDao dao) {
 156         this.dao = dao;
 157     }
 158
 159     @Override
 160     public int count(Class<? extends DescriptionBase> type, Boolean hasImages, Boolean hasText,Set<Feature> feature) {
 161         return dao.countDescriptions(type, hasImages, hasText, feature);
 162     }
 163
 164     @Override
 165     public Pager<DescriptionElementBase> pageDescriptionElements(DescriptionBase description, Class<? extends DescriptionBase> descriptionType,
 166             Set<Feature> features, Class<? extends DescriptionElementBase> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 167
 168         List<DescriptionElementBase> results = listDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);
 169         return new DefaultPagerImpl<DescriptionElementBase>(pageNumber, results.size(), pageSize, results);
 170     }
 171
 172     /* (non-Javadoc)
 173      * @see eu.etaxonomy.cdm.api.service.IDescriptionService#getDescriptionElements(eu.etaxonomy.cdm.model.description.DescriptionBase, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List)
 174      */
 175     @Override
 176     @Deprecated
 177     public Pager<DescriptionElementBase> getDescriptionElements(DescriptionBase description,
 178             Set<Feature> features, Class<? extends DescriptionElementBase> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 179         return pageDescriptionElements(description, null, features, type, pageSize, pageNumber, propertyPaths);
 180     }
 181
 182     @Override
 183     public List<DescriptionElementBase> listDescriptionElements(DescriptionBase description, Class<? extends DescriptionBase> descriptionType,
 184             Set<Feature> features, Class<? extends DescriptionElementBase> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 185
 186         Integer numberOfResults = dao.countDescriptionElements(description, descriptionType, features, type);
 187         List<DescriptionElementBase> results = new ArrayList<DescriptionElementBase>();
 188         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 189             results = dao.getDescriptionElements(description, descriptionType, features, type, pageSize, pageNumber, propertyPaths);
 190         }
 191         return results;
 192     }
 193
 194     /* (non-Javadoc)
 195      * @see eu.etaxonomy.cdm.api.service.IDescriptionService#listDescriptionElements(eu.etaxonomy.cdm.model.description.DescriptionBase, java.util.Set, java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List)
 196      */
 197     @Override
 198     @Deprecated
 199     public List<DescriptionElementBase> listDescriptionElements(DescriptionBase description,
 200             Set<Feature> features, Class<? extends DescriptionElementBase> type, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 201
 202         return listDescriptionElements(description, null, features, type, pageSize, pageNumber, propertyPaths);
 203     }
 204
 205     @Override
 206     public Pager<Annotation> getDescriptionElementAnnotations(DescriptionElementBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
 207         Integer numberOfResults = descriptionElementDao.countAnnotations(annotatedObj, status);
 208
 209         List<Annotation> results = new ArrayList<Annotation>();
 210         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 211             results = descriptionElementDao.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
 212         }
 213
 214         return new DefaultPagerImpl<Annotation>(pageNumber, numberOfResults, pageSize, results);
 215     }
 216
 217
 218
 219     @Override
 220     public Pager<Media> getMedia(DescriptionElementBase descriptionElement,     Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 221         Integer numberOfResults = descriptionElementDao.countMedia(descriptionElement);
 222
 223         List<Media> results = new ArrayList<Media>();
 224         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 225             results = descriptionElementDao.getMedia(descriptionElement, pageSize, pageNumber, propertyPaths);
 226         }
 227
 228         return new DefaultPagerImpl<Media>(pageNumber, numberOfResults, pageSize, results);
 229     }
 230
 231     @Override
 232     public Pager<TaxonDescription> pageTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 233         Set<MarkerType> markerTypes = null;
 234         return pageTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths);
 235     }
 236
 237     @Override
 238     public List<TaxonDescription> listTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 239         Set<MarkerType> markerTypes = null;
 240         return listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths);
 241     }
 242
 243
 244     /* (non-Javadoc)
 245      * @see eu.etaxonomy.cdm.api.service.IDescriptionService#pageMarkedTaxonDescriptions(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.util.Set, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List)
 246      */
 247     @Override
 248     public Pager<TaxonDescription> pageTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Set<MarkerType> markerTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 249         Integer numberOfResults = dao.countTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes);
 250
 251         List<TaxonDescription> results = new ArrayList<TaxonDescription>();
 252         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 253             results = dao.listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths);
 254         }
 255
 256         return new DefaultPagerImpl<TaxonDescription>(pageNumber, numberOfResults, pageSize, results);
 257     }
 258
 259     @Override
 260     public List<TaxonDescription> listTaxonDescriptions(Taxon taxon, Set<DefinedTerm> scopes, Set<NamedArea> geographicalScope, Set<MarkerType> markerTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 261         List<TaxonDescription> results = dao.listTaxonDescriptions(taxon, scopes, geographicalScope, markerTypes, pageSize, pageNumber, propertyPaths);
 262         return results;
 263     }
 264
 265
 266     /* (non-Javadoc)
 267      * @see eu.etaxonomy.cdm.api.service.IDescriptionService#listTaxonDescriptionMedia(UUID, boolean, Set, Integer, Integer, List)
 268      */
 269     @Override
 270     public List<Media> listTaxonDescriptionMedia(UUID taxonUuid, boolean limitToGalleries, Set<MarkerType> markerTypes, Integer pageSize, Integer pageNumber, List<String> propertyPaths){
 271         return this.dao.listTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes, pageSize, pageNumber, propertyPaths);
 272     }
 273
 274     /*
 275      * @see IDescriptionService#countTaxonDescriptionMedia(UUID, boolean, Set)
 276      */
 277     @Override
 278     public int countTaxonDescriptionMedia(UUID taxonUuid, boolean limitToGalleries, Set<MarkerType> markerTypes){
 279         return this.dao.countTaxonDescriptionMedia(taxonUuid, limitToGalleries, markerTypes);
 280     }
 281
 282
 283
 284
 285     @Override
 286     public DistributionTree getOrderedDistributions(
 287             Set<TaxonDescription> taxonDescriptions,
 288             Set<NamedAreaLevel> omitLevels,
 289             List<String> propertyPaths){
 290
 291         DistributionTree tree = new DistributionTree();
 292         List<Distribution> distList = new ArrayList<Distribution>();
 293
 294         for (TaxonDescription taxonDescription : taxonDescriptions) {
 295             taxonDescription = (TaxonDescription) dao.load(taxonDescription.getUuid(), propertyPaths);
 296             Set<DescriptionElementBase> elements = taxonDescription.getElements();
 297             for (DescriptionElementBase element : elements) {
 298                     if (element.isInstanceOf(Distribution.class)) {
 299                         Distribution distribution = (Distribution) element;
 300                         if(distribution.getArea() != null){
 301                             distList.add(distribution);
 302                         }
 303                     }
 304             }
 305         }
 306
 307         // filter distributions
 308         Collection<Distribution> filteredDistributions = DescriptionUtility.filterDistributions(distList);
 309         distList.clear();
 310         distList.addAll(filteredDistributions);
 311
 312         //order by areas
 313         tree.orderAsTree(distList, omitLevels);
 314         tree.sortChildren();
 315         return tree;
 316     }
 317
 318     @Override
 319     public Pager<TaxonNameDescription> getTaxonNameDescriptions(TaxonNameBase name, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 320         Integer numberOfResults = dao.countTaxonNameDescriptions(name);
 321
 322         List<TaxonNameDescription> results = new ArrayList<TaxonNameDescription>();
 323         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 324             results = dao.getTaxonNameDescriptions(name, pageSize, pageNumber,propertyPaths);
 325         }
 326
 327         return new DefaultPagerImpl<TaxonNameDescription>(pageNumber, numberOfResults, pageSize, results);
 328     }
 329
 330
 331     @Override
 332     public Pager<DescriptionBase> page(Class<? extends DescriptionBase> type, Boolean hasImages, Boolean hasText, Set<Feature> feature, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 333         Integer numberOfResults = dao.countDescriptions(type, hasImages, hasText, feature);
 334
 335         List<DescriptionBase> results = new ArrayList<DescriptionBase>();
 336         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 337             results = dao.listDescriptions(type, hasImages, hasText, feature, pageSize, pageNumber,orderHints,propertyPaths);
 338         }
 339
 340         return new DefaultPagerImpl<DescriptionBase>(pageNumber, numberOfResults, pageSize, results);
 341     }
 342
 343     /**
 344      * FIXME Candidate for harmonization
 345      * Rename: searchByDistribution
 346      */
 347     @Override
 348     public Pager<TaxonDescription> searchDescriptionByDistribution(Set<NamedArea> namedAreas, PresenceAbsenceTermBase presence, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 349         Integer numberOfResults = dao.countDescriptionByDistribution(namedAreas, presence);
 350
 351         List<TaxonDescription> results = new ArrayList<TaxonDescription>();
 352         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 353             results = dao.searchDescriptionByDistribution(namedAreas, presence, pageSize, pageNumber,orderHints,propertyPaths);
 354         }
 355
 356         return new DefaultPagerImpl<TaxonDescription>(pageNumber, numberOfResults, pageSize, results);
 357     }
 358
 359     /**
 360      * FIXME Candidate for harmonization
 361      * move: descriptionElementService.search
 362      */
 363     @Override
 364     public Pager<DescriptionElementBase> searchElements(Class<? extends DescriptionElementBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 365         Integer numberOfResults = descriptionElementDao.count(clazz, queryString);
 366
 367         List<DescriptionElementBase> results = new ArrayList<DescriptionElementBase>();
 368         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 369             results = descriptionElementDao.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
 370         }
 371
 372         return new DefaultPagerImpl<DescriptionElementBase>(pageNumber, numberOfResults, pageSize, results);
 373     }
 374
 375     /**
 376      * FIXME Candidate for harmonization
 377      * descriptionElementService.find
 378      */
 379     @Override
 380     public DescriptionElementBase getDescriptionElementByUuid(UUID uuid) {
 381         return descriptionElementDao.findByUuid(uuid);
 382     }
 383
 384     /**
 385      * FIXME Candidate for harmonization
 386      * descriptionElementService.load
 387      */
 388     @Override
 389     public DescriptionElementBase loadDescriptionElement(UUID uuid,     List<String> propertyPaths) {
 390         return descriptionElementDao.load(uuid, propertyPaths);
 391     }
 392
 393     /**
 394      * FIXME Candidate for harmonization
 395      * descriptionElementService.save
 396      */
 397     @Override
 398     @Transactional(readOnly = false)
 399     public UUID saveDescriptionElement(DescriptionElementBase descriptionElement) {
 400         return descriptionElementDao.save(descriptionElement);
 401     }
 402
 403     /**
 404      * FIXME Candidate for harmonization
 405      * descriptionElementService.save
 406      */
 407     @Override
 408     @Transactional(readOnly = false)
 409     public Map<UUID, DescriptionElementBase> saveDescriptionElement(Collection<DescriptionElementBase> descriptionElements) {
 410         return descriptionElementDao.saveAll(descriptionElements);
 411     }
 412
 413     /**
 414      * FIXME Candidate for harmonization
 415      * descriptionElementService.delete
 416      */
 417     @Override
 418     public UUID deleteDescriptionElement(DescriptionElementBase descriptionElement) {
 419         return descriptionElementDao.delete(descriptionElement);
 420     }
 421
 422     @Override
 423     public TermVocabulary<Feature> getFeatureVocabulary(UUID uuid) {
 424         return vocabularyDao.findByUuid(uuid);
 425     }
 426
 427     @Override
 428     @Deprecated
 429     public <T extends DescriptionElementBase> List<T> getDescriptionElementsForTaxon(
 430             Taxon taxon, Set<Feature> features,
 431             Class<T> type, Integer pageSize,
 432             Integer pageNumber, List<String> propertyPaths) {
 433         return listDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
 434     }
 435
 436     @Override
 437     public <T extends DescriptionElementBase> List<T> listDescriptionElementsForTaxon(
 438             Taxon taxon, Set<Feature> features,
 439             Class<T> type, Integer pageSize,
 440             Integer pageNumber, List<String> propertyPaths) {
 441         return dao.getDescriptionElementForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
 442     }
 443
 444     @Override
 445     public <T extends DescriptionElementBase> Pager<T> pageDescriptionElementsForTaxon(
 446             Taxon taxon, Set<Feature> features,
 447             Class<T> type, Integer pageSize,
 448             Integer pageNumber, List<String> propertyPaths) {
 449         Long count = dao.countDescriptionElementForTaxon(taxon, features, type);
 450         List<T> descriptionElements;
 451         if(AbstractPagerImpl.hasResultsInRange(count, pageNumber, pageSize)){ // no point checking again
 452             descriptionElements = listDescriptionElementsForTaxon(taxon, features, type, pageSize, pageNumber, propertyPaths);
 453         } else {
 454             descriptionElements = new ArrayList<T>(0);
 455         }
 456         return new DefaultPagerImpl<T>(pageNumber, count.intValue(), pageSize, descriptionElements);
 457     }
 458
 459
 460     /* (non-Javadoc)
 461      * @see eu.etaxonomy.cdm.api.service.IDescriptionService#generateNaturalLanguageDescription(eu.etaxonomy.cdm.model.description.FeatureTree, eu.etaxonomy.cdm.model.description.TaxonDescription, eu.etaxonomy.cdm.model.common.Language, java.util.List)
 462      */
 463     @Override
 464     public String generateNaturalLanguageDescription(FeatureTree featureTree,
 465             TaxonDescription description, List<Language> preferredLanguages, String separator) {
 466
 467         Language lang = preferredLanguages.size() > 0 ? preferredLanguages.get(0) : Language.DEFAULT();
 468
 469         description = (TaxonDescription)load(description.getUuid());
 470         featureTree = featureTreeDao.load(featureTree.getUuid());
 471
 472         StringBuilder naturalLanguageDescription = new StringBuilder();
 473
 474         MarkerType useMarkerType = (MarkerType) definedTermDao.load(UUID.fromString("2e6e42d9-e92a-41f4-899b-03c0ac64f039"));
 475         boolean isUseDescription = false;
 476         if(!description.getMarkers().isEmpty()) {
 477             for (Marker marker: description.getMarkers()) {
 478                 MarkerType markerType = marker.getMarkerType();
 479                 if (markerType.equals(useMarkerType)) {
 480                     isUseDescription = true;
 481                 }
 482
 483             }
 484         }
 485
 486         if(description.hasStructuredData() && !isUseDescription){
 487
 488
 489             String lastCategory = null;
 490             String categorySeparator = ". ";
 491
 492             List<TextData> textDataList;
 493             TextData naturalLanguageDescriptionText = null;
 494
 495             boolean useMicroFormatQuantitativeDescriptionBuilder = false;
 496
 497             if(useMicroFormatQuantitativeDescriptionBuilder){
 498
 499                 MicroFormatQuantitativeDescriptionBuilder micro = new MicroFormatQuantitativeDescriptionBuilder();
 500                 naturalLanguageGenerator.setQuantitativeDescriptionBuilder(micro);
 501                 naturalLanguageDescriptionText = naturalLanguageGenerator.generateSingleTextData(featureTree, (description), lang);
 502
 503             } else {
 504
 505                 naturalLanguageDescriptionText = naturalLanguageGenerator.generateSingleTextData(
 506                         featureTree,
 507                         (description),
 508                         lang);
 509             }
 510
 511             return naturalLanguageDescriptionText.getText(lang);
 512
 513 //
 514 //                      boolean doItBetter = false;
 515 //
 516 //                      for (TextData textData : textDataList.toArray(new TextData[textDataList.size()])){
 517 //                              if(textData.getMultilanguageText().size() > 0){
 518 //
 519 //                                      if (!textData.getFeature().equals(Feature.UNKNOWN())) {
 520 //                                              String featureLabel = textData.getFeature().getLabel(lang);
 521 //
 522 //                                              if(doItBetter){
 523 //                                                      /*
 524 //                                                       *  WARNING
 525 //                                                       *  The code lines below are desinged to handle
 526 //                                                       *  a special case where as the feature label contains
 527 //                                                       *  hierarchical information on the features. This code
 528 //                                                       *  exist only as a base for discussion, and is not
 529 //                                                       *  intendet to be used in production.
 530 //                                                       */
 531 //                                                      featureLabel = StringUtils.remove(featureLabel, '>');
 532 //
 533 //                                                      String[] labelTokens = StringUtils.split(featureLabel, '<');
 534 //                                                      if(labelTokens[0].equals(lastCategory) && labelTokens.length > 1){
 535 //                                                              if(naturalLanguageDescription.length() > 0){
 536 //                                                                      naturalLanguageDescription.append(separator);
 537 //                                                              }
 538 //                                                              naturalLanguageDescription.append(labelTokens[1]);
 539 //                                                      } else {
 540 //                                                              if(naturalLanguageDescription.length() > 0){
 541 //                                                                      naturalLanguageDescription.append(categorySeparator);
 542 //                                                              }
 543 //                                                              naturalLanguageDescription.append(StringUtils.join(labelTokens));
 544 //                                                      }
 545 //                                                      lastCategory = labelTokens[0];
 546 //                                                      // end of demo code
 547 //                                              } else {
 548 //                                                      if(naturalLanguageDescription.length() > 0){
 549 //                                                              naturalLanguageDescription.append(separator);
 550 //                                                      }
 551 //                                                      naturalLanguageDescription.append(textData.getFeature().getLabel(lang));
 552 //                                              }
 553 //                                      } else {
 554 //                                              if(naturalLanguageDescription.length() > 0){
 555 //                                                      naturalLanguageDescription.append(separator);
 556 //                                              }
 557 //                                      }
 558 //                                      String text = textData.getMultilanguageText().values().iterator().next().getText();
 559 //                                      naturalLanguageDescription.append(text);
 560 //
 561 //                              }
 562 //                      }
 563
 564         }
 565         else if (isUseDescription) {
 566             //AT: Left Blank in case we need to generate a Natural language text string.
 567         }
 568         return naturalLanguageDescription.toString();
 569     }
 570
 571     /* (non-Javadoc)
 572      * @see eu.etaxonomy.cdm.api.service.IDescriptionService#hasStructuredData(eu.etaxonomy.cdm.model.description.DescriptionBase)
 573      */
 574     @Override
 575     public boolean hasStructuredData(DescriptionBase<?> description) {
 576         return load(description.getUuid()).hasStructuredData();
 577     }
 578
 579
 580     /* (non-Javadoc)
 581      * @see eu.etaxonomy.cdm.api.service.IDescriptionService#moveDescriptionElementsToDescription(java.util.Collection, eu.etaxonomy.cdm.model.description.DescriptionBase, boolean)
 582      */
 583     @Override
 584     public void moveDescriptionElementsToDescription(Collection<DescriptionElementBase> descriptionElements,
 585                                                     DescriptionBase targetDescription, boolean isCopy) {
 586
 587         if (descriptionElements.isEmpty() ){
 588             return ;
 589         }
 590
 591         if (! isCopy && descriptionElements == descriptionElements.iterator().next().getInDescription().getElements()){
 592             //if the descriptionElements collection is the elements set of a description, put it in a separate set before to avoid concurrent modification exceptions
 593             descriptionElements = new HashSet<DescriptionElementBase>(descriptionElements);
 594 //                      descriptionElementsTmp.addAll(descriptionElements);
 595 //                      descriptionElements = descriptionElementsTmp;
 596         }
 597         for (DescriptionElementBase element : descriptionElements){
 598             DescriptionBase description = element.getInDescription();
 599             try {
 600                 DescriptionElementBase newElement = (DescriptionElementBase)element.clone();
 601                 targetDescription.addElement(newElement);
 602             } catch (CloneNotSupportedException e) {
 603                 new RuntimeException ("Clone not yet implemented for class " + element.getClass().getName(), e);
 604             }
 605             if (! isCopy){
 606                 description.removeElement(element);
 607             }
 608
 609         }
 610     }
 611
 612     public void aggregateDistributions(List<NamedArea> superAreas, Rank lowerRank, Rank upperRank) {
 613
 614 //        transmissionEngineDistribution engine = new transmissionEngineDistribution(superAreas, lowerRank, upperRank);
 615
 616     }
 617
 618 }