cdmlib-model/src/main/java/eu/etaxonomy/cdm/strategy/cache/name/NameCacheStrategyBase.java

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9 package eu.etaxonomy.cdm.strategy.cache.name;
  10
  11 import java.util.ArrayList;
  12 import java.util.Iterator;
  13 import java.util.List;
  14 import java.util.Set;
  15 import java.util.UUID;
  16
  17 import org.apache.log4j.Logger;
  18
  19 import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
  20 import eu.etaxonomy.cdm.model.common.CdmBase;
  21 import eu.etaxonomy.cdm.model.common.Language;
  22 import eu.etaxonomy.cdm.model.name.INonViralName;
  23 import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;
  24 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  25 import eu.etaxonomy.cdm.model.name.TaxonName;
  26 import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
  27 import eu.etaxonomy.cdm.model.reference.Reference;
  28 import eu.etaxonomy.cdm.model.term.Representation;
  29 import eu.etaxonomy.cdm.ref.TypedEntityReference;
  30 import eu.etaxonomy.cdm.strategy.StrategyBase;
  31 import eu.etaxonomy.cdm.strategy.cache.HTMLTagRules;
  32 import eu.etaxonomy.cdm.strategy.cache.TagEnum;
  33 import eu.etaxonomy.cdm.strategy.cache.TaggedCacheHelper;
  34 import eu.etaxonomy.cdm.strategy.cache.TaggedText;
  35
  36 /**
  37  * @author AM
  38  */
  39 public abstract class NameCacheStrategyBase
  40         extends StrategyBase
  41         implements INameCacheStrategy {
  42     private static final long serialVersionUID = -2322348388258675517L;
  43
  44     private static final Logger logger = Logger.getLogger(NameCacheStrategyBase.class);
  45
  46     final static UUID uuid = UUID.fromString("817ae5b5-3ac2-414b-a134-a9ae86cba040");
  47
  48     public NameCacheStrategyBase() {
  49         super();
  50     }
  51
  52     @Override
  53     public String getFullTitleCache(TaxonName taxonName, HTMLTagRules htmlTagRules) {
  54         List<TaggedText> tags = getTaggedFullTitle(taxonName);
  55         if (tags == null){
  56             return null;
  57         }else{
  58             String result = createString(tags, htmlTagRules);
  59             return result;
  60         }
  61     }
  62
  63     @Override
  64     public String getFullTitleCache(TaxonName taxonName) {
  65         return getFullTitleCache(taxonName, null);
  66     }
  67
  68     @Override
  69     public List<TaggedText> getNomStatusTags(TaxonName taxonName, boolean includeSeparatorBefore,
  70             boolean includeSeparatorAfter) {
  71
  72         Set<NomenclaturalStatus> ncStati = taxonName.getStatus();
  73         Iterator<NomenclaturalStatus> iterator = ncStati.iterator();
  74         List<TaggedText> nomStatusTags = new ArrayList<>();
  75         while (iterator.hasNext()) {
  76             NomenclaturalStatus ncStatus = iterator.next();
  77             // since the NewInstance method of nomencatural status allows null as parameter
  78             // we have to check for null values here
  79             String nomStatusStr = "not defined";
  80             if(ncStatus.getType() != null){
  81                 NomenclaturalStatusType statusType =  ncStatus.getType();
  82                 Language lang = Language.LATIN();
  83                 Representation repr = statusType.getRepresentation(lang);
  84                 if (repr != null){
  85                     nomStatusStr = repr.getAbbreviatedLabel();
  86                 }else{
  87                     String message = "No latin representation available for nom. status. " + statusType.getTitleCache();
  88                     logger.warn(message);
  89                     throw new IllegalStateException(message);
  90                 }
  91             }else if(isNotBlank(ncStatus.getRuleConsidered())){
  92                 nomStatusStr = ncStatus.getRuleConsidered();
  93             }
  94             String statusSeparator = ", ";
  95             if (includeSeparatorBefore){
  96                 nomStatusTags.add(new TaggedText(TagEnum.separator, statusSeparator));
  97             }
  98             nomStatusTags.add(new TaggedText(TagEnum.nomStatus, nomStatusStr, new TypedEntityReference<>(ncStatus.getClass(), ncStatus.getUuid())));
  99             if (includeSeparatorAfter){
 100                 nomStatusTags.add(new TaggedText(TagEnum.postSeparator, ","));
 101             }
 102         }
 103         return nomStatusTags;
 104     }
 105
 106     @Override
 107     public String getNameCache(TaxonName nonViralName) {
 108         List<TaggedText> tags = getTaggedName(nonViralName);
 109         if (tags == null){
 110             return null;
 111         }else{
 112             String result = createString(tags);
 113             return result;
 114         }
 115     }
 116
 117     @Override
 118     public String getNameCache(TaxonName nonViralName, HTMLTagRules htmlTagRules) {
 119         List<TaggedText> tags = getTaggedName(nonViralName);
 120         if (tags == null){
 121             return null;
 122         }else{
 123             String result = createString(tags, htmlTagRules);
 124             return result;
 125         }
 126     }
 127
 128     /**
 129      * Generates and returns the title cache of the given name.
 130      * The title cache in general includes the name and the authorship and year for some types of names.
 131      *
 132      * @see eu.etaxonomy.cdm.strategy.INameCacheStrategy#getTitleCache(eu.etaxonomy.cdm.model.common.CdmBase)
 133      * @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy#getTitleCache(eu.etaxonomy.cdm.model.common.IdentifiableEntity)
 134      */
 135     @Override
 136     public String getTitleCache(TaxonName taxonName) {
 137         return getTitleCache(taxonName, null);
 138     }
 139
 140     @Override
 141     public String getTitleCache(TaxonName taxonName, HTMLTagRules htmlTagRules) {
 142         List<TaggedText> tags = getTaggedTitle(taxonName);
 143         if (tags == null){
 144             return null;
 145         }else{
 146             String result = createString(tags, htmlTagRules);
 147             return result;
 148         }
 149     }
 150
 151     @Override
 152     public List<TaggedText> getTaggedTitle(TaxonName taxonName) {
 153         if (taxonName == null){
 154             return null;
 155         }
 156         //TODO how to handle protected fullTitleCache here?
 157
 158         if (taxonName.isProtectedTitleCache()){
 159             //protected title cache
 160             List<TaggedText> tags = new ArrayList<>();
 161             tags.add(new TaggedText(TagEnum.name, taxonName.getTitleCache()));
 162             return tags;
 163         }else{
 164             return doGetTaggedTitle(taxonName);
 165         }
 166     }
 167
 168     protected abstract List<TaggedText> doGetTaggedTitle(TaxonName taxonName);
 169
 170     @Override
 171     public List<TaggedText> getTaggedFullTitle(TaxonName taxonName) {
 172         List<TaggedText> tags = new ArrayList<>();
 173
 174         //null
 175         if (taxonName == null){
 176             return null;
 177         }
 178
 179         //protected full title cache
 180         if (taxonName.isProtectedFullTitleCache()){
 181             tags.add(new TaggedText(TagEnum.fullName, taxonName.getFullTitleCache()));
 182             return tags;
 183         }
 184
 185         //title cache
 186 //      String titleCache = nonViralName.getTitleCache();
 187         List<TaggedText> titleTags = getTaggedTitle(taxonName);
 188         tags.addAll(titleTags);
 189
 190         //reference
 191         String microReference = taxonName.getNomenclaturalMicroReference();
 192         INomenclaturalReference ref = taxonName.getNomenclaturalReference();
 193         String referenceCache = null;
 194         if (ref != null){
 195             Reference reference = HibernateProxyHelper.deproxy(ref, Reference.class);
 196             referenceCache = reference.getNomenclaturalCitation(microReference);
 197         }
 198             //add to tags
 199         if (isNotBlank(referenceCache)){
 200             if (! referenceCache.trim().startsWith("in ")){
 201                 String refConcat = ", ";
 202                 tags.add(new TaggedText(TagEnum.separator, refConcat));
 203             }
 204             tags.add(new TaggedText(TagEnum.reference, referenceCache));
 205         }
 206
 207         addOriginalSpelling(tags, taxonName);
 208
 209         //nomenclatural status
 210         tags.addAll(getNomStatusTags(taxonName, true, false));
 211         return tags;
 212     }
 213
 214     protected void addOriginalSpelling(List<TaggedText> tags, TaxonName taxonName){
 215         String originalName = getOriginalNameString(taxonName, tags);
 216         if (isNotBlank(originalName)){
 217             tags.add(new TaggedText(TagEnum.name, originalName));
 218         }
 219     }
 220
 221     private String getOriginalNameString(TaxonName currentName, List<TaggedText> originalNameTaggs) {
 222         currentName = CdmBase.deproxy(currentName);
 223         //Hibernate.initialize(currentName.getRelationsToThisName());
 224         TaxonName originalName = currentName.getOriginalSpelling();
 225         if (originalName != null){
 226             String originalNameString;
 227             if (!originalName.isNonViral()){
 228                 originalNameString = originalName.getTitleCache();
 229             }else{
 230                 INonViralName originalNvName = CdmBase.deproxy(originalName);
 231                 originalNameString = makeOriginalNameString(currentName, originalNvName, originalNameTaggs);
 232             }
 233             return "[as \"" + originalNameString + "\"]";
 234         }else{
 235             return null;
 236         }
 237     }
 238
 239     private String makeOriginalNameString(TaxonName currentName, INonViralName originalName,
 240             List<TaggedText> currentNameTags) {
 241         //use cache if necessary
 242         String cacheToUse = null;
 243         if (originalName.isProtectedNameCache() && isNotBlank(originalName.getNameCache())){
 244             cacheToUse = originalName.getNameCache();
 245         }else if (originalName.isProtectedTitleCache() && isNotBlank(originalName.getTitleCache())){
 246             cacheToUse = originalName.getTitleCache();
 247         }else if (originalName.isProtectedFullTitleCache() && isNotBlank(originalName.getFullTitleCache())){
 248             cacheToUse = originalName.getFullTitleCache();
 249         }
 250         if (cacheToUse != null){
 251             return cacheToUse;
 252         }
 253         //use atomized data
 254         //get originalNameParts array
 255         String originalNameString = originalName.getNameCache();
 256         if (originalNameString == null){
 257             originalNameString = originalName.getTitleCache();
 258         }
 259         if (originalNameString == null){  //should not happen
 260             originalNameString = originalName.getFullTitleCache();
 261         }
 262         String[] originalNameSplit = originalNameString.split("\\s+");
 263
 264         //get current name parts
 265         String currentNameString = createString(currentNameTags);
 266         String[] currentNameSplit = currentNameString.split("\\s+");
 267
 268         //compute string
 269         String result = originalNameString;
 270         for (int i = 0; i < Math.min(originalNameSplit.length, currentNameSplit.length); i++){
 271             if (originalNameSplit[i].equals(currentNameSplit[i])){
 272                 result = result.replaceFirst(originalNameSplit[i], "").trim();
 273             }
 274         }
 275         //old
 276 //      if (originalName.getGenusOrUninomial() != null && originalName.getGenusOrUninomial().equals(currentName.getGenusOrUninomial())){
 277 //
 278 //      }
 279         return result;
 280     }
 281
 282     protected String createString(List<TaggedText> tags) {
 283         return TaggedCacheHelper.createString(tags);
 284     }
 285
 286     protected String createString(List<TaggedText> tags, HTMLTagRules htmlTagRules) {
 287         return TaggedCacheHelper.createString(tags, htmlTagRules);
 288     }
 289 }