cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/taxonx/TaxonXTransformer.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.io.taxonx;
  10
  11 import org.apache.logging.log4j.LogManager;
  12 import org.apache.logging.log4j.Logger;
  13
  14 import eu.etaxonomy.cdm.model.common.IRelationshipType;
  15 import eu.etaxonomy.cdm.model.description.Feature;
  16 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  17 import eu.etaxonomy.cdm.model.name.Rank;
  18 import eu.etaxonomy.cdm.model.name.SpecimenTypeDesignationStatus;
  19 import eu.etaxonomy.cdm.model.taxon.SynonymType;
  20 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  21 import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
  22
  23 /**
  24  * @author a.mueller
  25  * @since 29.07.2008
  26  */
  27 public final class TaxonXTransformer {
  28
  29         @SuppressWarnings("unused")
  30     private static final Logger logger = LogManager.getLogger();
  31
  32         //Facts
  33         public static int FACT_DESCRIPTION = 1;
  34         public static int FACT_GROWTH_FORM = 2;
  35         public static int FACT_HARDINESS = 3;
  36         public static int FACT_ECOLOGY = 4;
  37         public static int FACT_PHENOLOGY = 5;
  38         public static int FACT_KARYOLOGY = 6;
  39         public static int FACT_ILLUSTRATION = 7;
  40         public static int FACT_IDENTIFICATION = 8;
  41         public static int FACT_OBSERVATION = 9;
  42         public static int FACT_DISTIRBUTION_EM = 10;
  43         public static int FACT_DISTIRBUTION_WORLD = 11;
  44
  45         //TypeDesignation
  46         public static SpecimenTypeDesignationStatus typeStatusId2TypeStatus (int typeStatusId)  throws UnknownCdmTypeException{
  47                 switch (typeStatusId){
  48                         case 1: return SpecimenTypeDesignationStatus.HOLOTYPE();
  49                         case 2: return SpecimenTypeDesignationStatus.LECTOTYPE();
  50                         case 3: return SpecimenTypeDesignationStatus.NEOTYPE();
  51                         case 4: return SpecimenTypeDesignationStatus.EPITYPE();
  52                         case 5: return SpecimenTypeDesignationStatus.ISOLECTOTYPE();
  53                         case 6: return SpecimenTypeDesignationStatus.ISONEOTYPE();
  54                         case 7: return SpecimenTypeDesignationStatus.ISOTYPE();
  55                         case 8: return SpecimenTypeDesignationStatus.PARANEOTYPE();
  56                         case 9: return SpecimenTypeDesignationStatus.PARATYPE();
  57                         case 10: return SpecimenTypeDesignationStatus.SECOND_STEP_LECTOTYPE();
  58                         case 11: return SpecimenTypeDesignationStatus.SECOND_STEP_NEOTYPE();
  59                         case 12: return SpecimenTypeDesignationStatus.SYNTYPE();
  60                         case 21: return SpecimenTypeDesignationStatus.ICONOTYPE();
  61                         case 22: return SpecimenTypeDesignationStatus.PHOTOTYPE();
  62                         default: {
  63                                 throw new UnknownCdmTypeException("Unknown TypeDesignationStatus (id=" + Integer.valueOf(typeStatusId).toString() + ")");
  64                         }
  65                 }
  66         }
  67
  68
  69
  70
  71         /** Creates an cdm-Rank by the tcs rank
  72          */
  73         public static Rank rankString2Rank (String strRank) throws UnknownCdmTypeException{
  74                 String tcsRoot = "http://rs.tdwg.org/ontology/voc/TaxonRank#";
  75                 String tcsGenus = tcsRoot + "Genus";
  76                 String tcsSpecies = tcsRoot + "Species";
  77 //              String tcsGenus = tcsRoot + "Genus";
  78
  79                 if (strRank == null){return null;
  80                 }else if (tcsGenus.equals(strRank)){return Rank.GENUS();
  81                 }else if (tcsSpecies.equals(strRank)){return Rank.SPECIES();
  82                 }
  83                 else {
  84                         throw new UnknownCdmTypeException("Unknown Rank " + strRank);
  85                 }
  86         }
  87
  88         /** Creates an cdm-NomenclaturalCode by the tcs NomenclaturalCode
  89          */
  90         public static Feature descriptionType2feature (String descriptionType) throws UnknownCdmTypeException{
  91                 if (descriptionType == null){ return null;
  92 //              }else if ("abstract".equals(descriptionType)){return Feature.XX();
  93 //              }else if ("acknowledgments".equals(descriptionType)){return Feature.ICZN();
  94                 }else if ("biology_ecology".equals(descriptionType)){return Feature.BIOLOGY_ECOLOGY();
  95                 }else if ("description".equals(descriptionType)){return Feature.DESCRIPTION();
  96                 }else if ("cultivation".equals(descriptionType)){return Feature.CULTIVATION();
  97                 }else if ("conservation".equals(descriptionType)){return Feature.CONSERVATION();
  98                 }else if ("diagnosis".equals(descriptionType)){return Feature.DIAGNOSIS();
  99                 }else if ("Description".equals(descriptionType)){return Feature.DESCRIPTION();
 100                 }else if ("discussion".equals(descriptionType)){return Feature.DISCUSSION();
 101                 }else if ("distribution".equals(descriptionType)){return Feature.DISTRIBUTION();
 102                 }else if ("etymology".equals(descriptionType)){return Feature.ETYMOLOGY();
 103                 }else if ("key".equals(descriptionType)){return Feature.KEY();
 104                 }else if ("introduction".equals(descriptionType)){return Feature.INTRODUCTION();
 105                 }else if ("materials_examined".equals(descriptionType)){return Feature.MATERIALS_EXAMINED();
 106                 }else if ("materials_methods".equals(descriptionType)){return Feature.MATERIALS_METHODS();
 107 //              }else if ("multiple".equals(descriptionType)){return Feature.multi;
 108 //              }else if ("synopsis".equals(descriptionType)){return Feature.synopsis;
 109                 }else if ("uses".equals(descriptionType)){return Feature.USES();
 110                 }else if ("vernacular".equals(descriptionType)){return Feature.COMMON_NAME();
 111                 }else if ("anatomy".equals(descriptionType)){return Feature.ANATOMY();
 112                 }else {
 113                         throw new UnknownCdmTypeException("Unknown Description Type: " + descriptionType);
 114                 }
 115         }
 116
 117         public static boolean isReverseRelationshipCategory (String tcsRelationshipCategory){
 118                 String str = tcsRelationshipCategory.replace("http://rs.tdwg.org/ontology/voc/TaxonConcept#", "");
 119                 if ("HasSynonym".equalsIgnoreCase(str)
 120                                 || "IsParentTaxonOf".equalsIgnoreCase(str)
 121                                 || "IsIncludedIn".equalsIgnoreCase(str)
 122                                 || "DoesNotInclude".equalsIgnoreCase(str)
 123                                                                         ){
 124
 125                         return true;
 126                 }
 127                 return false;
 128         }
 129
 130         /**
 131          * Creates an cdm-RelationshipTermBase by the tcsRelationshipCategory
 132          */
 133         public static IRelationshipType tcsRelationshipCategory2Relationship (String tcsRelationshipCategory) throws UnknownCdmTypeException{
 134                 String tcsRoot = "http://rs.tdwg.org/ontology/voc/TaxonConcept#";
 135                 String doesNotInclude  = tcsRoot + "DoesNotInclude";
 136                 String doesNotOverlap  = tcsRoot + "DoesNotOverlap";
 137                 String excludes  = tcsRoot + "Excludes";
 138                 String hasSynonym  = tcsRoot + "HasSynonym";
 139                 String hasVernacular  = tcsRoot + "HasVernacular";
 140                 String includes  = tcsRoot + "Includes";
 141                 String isAmbiregnalOf  = tcsRoot + "IsAmbiregnalOf";
 142                 String isAnamorphOf  = tcsRoot + "IsAnamorphOf";
 143                 String isChildTaxonOf  = tcsRoot + "IsChildTaxonOf";
 144                 String isCongruentTo  = tcsRoot + "IsCongruentTo";
 145                 String isFemaleParentOf  = tcsRoot + "IsFemaleParentOf";
 146                 String isFirstParentOf  = tcsRoot + "IsFirstParentOf";
 147                 String isHybridChildOf  = tcsRoot + "IsHybridChildOf";
 148                 String isHybridParentOf  = tcsRoot + "IsHybridParentOf";
 149                 String isIncludedIn  = tcsRoot + "IsIncludedIn";
 150                 String isMaleParentOf  = tcsRoot + "IsMaleParentOf";
 151                 String isNotCongruentTo  = tcsRoot + "IsNotCongruentTo";
 152                 String isNotIncludedIn  = tcsRoot + "IsNotIncludedIn";
 153                 String isParentTaxonOf  = tcsRoot + "IsParentTaxonOf";
 154                 String isSecondParentOf  = tcsRoot + "IsSecondParentOf";
 155                 String isSynonymFor  = tcsRoot + "IsSynonymFor";
 156                 String isTeleomorphOf  = tcsRoot + "IsTeleomorphOf";
 157                 String isVernacularFor  = tcsRoot + "IsVernacularFor";
 158                 String overlaps  = tcsRoot + "Overlaps";
 159
 160                 if (tcsRelationshipCategory == null){ return null;
 161
 162                 //Synonym relationships
 163                 }else if (isSynonymFor.equals(tcsRelationshipCategory)){return SynonymType.SYNONYM_OF;
 164                 }else if (hasSynonym.equals(tcsRelationshipCategory)){/*isReverse = true; */ return SynonymType.SYNONYM_OF;
 165
 166                 //Taxon relationships
 167                 }else if (isChildTaxonOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN();
 168                 }else if (isParentTaxonOf.equals(tcsRelationshipCategory)){/*isReverse = true; */ return TaxonRelationshipType.TAXONOMICALLY_INCLUDED_IN();
 169
 170                 //concept relationships
 171                 }else if (doesNotOverlap.equals(tcsRelationshipCategory)){return TaxonRelationshipType.DOES_NOT_OVERLAP();
 172                 }else if (excludes.equals(tcsRelationshipCategory)){return TaxonRelationshipType.EXCLUDES();
 173                 }else if (includes.equals(tcsRelationshipCategory)){return TaxonRelationshipType.INCLUDES();
 174                 }else if (isCongruentTo.equals(tcsRelationshipCategory)){return TaxonRelationshipType.CONGRUENT_TO();
 175                 }else if (isNotCongruentTo.equals(tcsRelationshipCategory)){return TaxonRelationshipType.NOT_CONGRUENT_TO();
 176                 }else if (isNotIncludedIn.equals(tcsRelationshipCategory)){return TaxonRelationshipType.NOT_INCLUDED_IN();
 177                 }else if (overlaps.equals(tcsRelationshipCategory)){return TaxonRelationshipType.OVERLAPS();
 178                 //reverse concept relationships
 179                 }else if (isIncludedIn.equals(tcsRelationshipCategory)){/*isReverse = true; */ return TaxonRelationshipType.INCLUDES();
 180                 }else if (doesNotInclude.equals(tcsRelationshipCategory)){/*isReverse = true; */ return TaxonRelationshipType.NOT_INCLUDED_IN();
 181
 182         //TODO
 183 //              }else if (hasVernacular.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 184 //              }else if (isAmbiregnalOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 185 //              }else if (isAnamorphOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 186 //              }else if (isFemaleParentOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 187 //              }else if (isFirstParentOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 188 //              }else if (isHybridChildOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 189 //              }else if (isHybridParentOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 190 //              }else if (isMaleParentOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 191 //              }else if (isSecondParentOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 192 //              }else if (isTeleomorphOf.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 193 //              }else if (isVernacularFor.equals(tcsRelationshipCategory)){return TaxonRelationshipType.X;
 194
 195                 }else {
 196                         throw new UnknownCdmTypeException("Unknown RelationshipCategory " + tcsRelationshipCategory);
 197                 }
 198         }
 199
 200
 201         /**
 202          * Creates an cdm-NomenclaturalCode by the tcs NomenclaturalCode
 203          */
 204         public static NomenclaturalStatusType nomStatusString2NomStatus (String nomStatus) throws UnknownCdmTypeException{
 205
 206                 if (nomStatus == null){ return null;
 207                 }else if ("Valid".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.VALID();
 208
 209                 }else if ("Alternative".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.ALTERNATIVE();
 210                 }else if ("nom. altern.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.ALTERNATIVE();
 211
 212                 }else if ("Ambiguous".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.AMBIGUOUS();
 213
 214                 }else if ("Doubtful".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.DOUBTFUL();
 215
 216                 }else if ("Confusum".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.CONFUSUM();
 217
 218                 }else if ("Illegitimate".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.ILLEGITIMATE();
 219                 }else if ("nom. illeg.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.ILLEGITIMATE();
 220
 221                 }else if ("Superfluous".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.SUPERFLUOUS();
 222                 }else if ("nom. superfl.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.SUPERFLUOUS();
 223
 224                 }else if ("Rejected".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.REJECTED();
 225                 }else if ("nom. rej.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.REJECTED();
 226
 227                 }else if ("Utique Rejected".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.UTIQUE_REJECTED();
 228
 229                 }else if ("Conserved Prop".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.CONSERVED_PROP();
 230
 231                 }else if ("Orthography Conserved Prop".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.ORTHOGRAPHY_CONSERVED_PROP();
 232
 233                 }else if ("Legitimate".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.LEGITIMATE();
 234
 235                 }else if ("Novum".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.NOVUM();
 236                 }else if ("nom. nov.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.NOVUM();
 237
 238                 }else if ("Utique Rejected Prop".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.UTIQUE_REJECTED_PROP();
 239
 240                 }else if ("Orthography Conserved".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.ORTHOGRAPHY_CONSERVED();
 241
 242                 }else if ("Rejected Prop".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.REJECTED_PROP();
 243
 244                 }else if ("Conserved".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.CONSERVED();
 245                 }else if ("nom. cons.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.CONSERVED();
 246
 247                 }else if ("Sanctioned".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.SANCTIONED();
 248
 249                 }else if ("Invalid".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.INVALID();
 250                 }else if ("nom. inval.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.INVALID();
 251
 252                 }else if ("Nudum".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.NUDUM();
 253                 }else if ("nom. nud.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.NUDUM();
 254
 255                 }else if ("Combination Invalid".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.COMBINATION_INVALID();
 256
 257                 }else if ("Provisional".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.PROVISIONAL();
 258                 }else if ("nom. provis.".equalsIgnoreCase(nomStatus)){return NomenclaturalStatusType.PROVISIONAL();
 259                 }
 260                 else {
 261                         throw new UnknownCdmTypeException("Unknown Nomenclatural status type " + nomStatus);
 262                 }
 263         }
 264
 265 }