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