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