cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/berlinModel/in/BerlinModelTaxonRelationImport.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
  10 package eu.etaxonomy.cdm.io.berlinModel.in;
  11
  12 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_HETEROTYPIC_SYNONYM_OF;
  13 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_HOMOTYPIC_SYNONYM_OF;
  14 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_INCLUDED_IN;
  15 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_MISAPPLIED_NAME_OF;
  16 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF;
  17 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF;
  18 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PARTIAL_SYN_OF;
  19 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF;
  20 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF;
  21 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_PROPARTE_SYN_OF;
  22 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.TAX_REL_IS_SYNONYM_OF;
  23
  24 import java.sql.ResultSet;
  25 import java.sql.SQLException;
  26 import java.util.HashMap;
  27 import java.util.HashSet;
  28 import java.util.Map;
  29 import java.util.Set;
  30 import java.util.UUID;
  31
  32 import org.apache.log4j.Logger;
  33 import org.springframework.stereotype.Component;
  34
  35 import eu.etaxonomy.cdm.common.CdmUtils;
  36 import eu.etaxonomy.cdm.common.ResultWrapper;
  37 import eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer;
  38 import eu.etaxonomy.cdm.io.berlinModel.in.validation.BerlinModelTaxonRelationImportValidator;
  39 import eu.etaxonomy.cdm.io.common.IOValidator;
  40 import eu.etaxonomy.cdm.io.common.ResultSetPartitioner;
  41 import eu.etaxonomy.cdm.io.common.Source;
  42 import eu.etaxonomy.cdm.model.common.AnnotatableEntity;
  43 import eu.etaxonomy.cdm.model.common.CdmBase;
  44 import eu.etaxonomy.cdm.model.common.IdentifiableSource;
  45 import eu.etaxonomy.cdm.model.reference.Reference;
  46 import eu.etaxonomy.cdm.model.taxon.Synonym;
  47 import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
  48 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
  49 import eu.etaxonomy.cdm.model.taxon.Taxon;
  50 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  51 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  52 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  53 import eu.etaxonomy.cdm.model.taxon.Classification;
  54 import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
  55
  56 /**
  57  * @author a.mueller
  58  * @created 20.03.2008
  59  * @version 1.0
  60  */
  61 @Component
  62 public class BerlinModelTaxonRelationImport  extends BerlinModelImportBase  {
  63         private static final Logger logger = Logger.getLogger(BerlinModelTaxonRelationImport.class);
  64
  65         public static final String TREE_NAMESPACE = "PTRefFk";
  66
  67         private static int modCount = 30000;
  68         private static final String pluralString = "taxon relations";
  69         private static final String dbTableName = "RelPTaxon";
  70
  71
  72         public BerlinModelTaxonRelationImport(){
  73                 super();
  74         }
  75
  76         /**
  77          * Creates a classification for each PTaxon reference which belongs to a taxon that is included at least in one
  78          * <i>taxonomically included</i> relationship
  79          * @param state
  80          * @return
  81          * @throws SQLException
  82          */
  83         private void makeClassifications(BerlinModelImportState state) throws SQLException{
  84                 logger.info("start make classification ...");
  85                 Source source = state.getConfig().getSource();
  86
  87                 Set<String> idSet = getTreeReferenceIdSet(source);
  88
  89                 //nom reference map
  90                 String nameSpace = BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE;
  91                 Class cdmClass = Reference.class;
  92                 idSet = new HashSet<String>();
  93                 Map<String, Reference> nomRefMap = (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
  94
  95                 //biblio reference map
  96                 nameSpace = BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE;
  97                 cdmClass = Reference.class;
  98 //              idSet = new HashSet<String>();
  99                 Map<String, Reference> biblioRefMap = (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 100
 101                 ResultSet rs = source.getResultSet(getClassificationQuery()) ;
 102                 int i = 0;
 103                 //for each reference
 104                 try {
 105                         while (rs.next()){
 106
 107                                 try {
 108                                         if ((i++ % modCount) == 0 && i!= 1 ){ logger.info("RelPTaxa handled: " + (i-1));}
 109
 110                                         Object ptRefFkObj = rs.getObject("PTRefFk");
 111                                         String ptRefFk= String.valueOf(ptRefFkObj);
 112                                         Reference<?> ref = getReferenceOnlyFromMaps(biblioRefMap, nomRefMap, ptRefFk);
 113
 114                                         rs.getString("RefCache");
 115                                         String treeName = "Classification - No Name";
 116                                         String refCache = rs.getString("RefCache");
 117                                         if (CdmUtils.isNotEmpty(refCache)){
 118                                                 treeName = refCache;
 119                                         }
 120                                         if (ref != null && CdmUtils.isNotEmpty(ref.getTitleCache())){
 121                                                 treeName = ref.getTitleCache();
 122                                         }
 123                                         Classification tree = Classification.NewInstance(treeName);
 124                                         tree.setReference(ref);
 125                                         if (i == 1 && state.getConfig().getClassificationUuid() != null){
 126                                                 tree.setUuid(state.getConfig().getClassificationUuid());
 127                                         }
 128                                         IdentifiableSource identifiableSource = IdentifiableSource.NewInstance(ptRefFk, TREE_NAMESPACE);
 129                                         tree.addSource(identifiableSource);
 130
 131                                         getClassificationService().save(tree);
 132                                         state.putClassificationUuidInt((Integer)ptRefFkObj, tree);
 133                                 } catch (Exception e) {
 134                                         logger.error("Error in BerlinModleTaxonRelationImport.makeClassifications: " + e.getMessage());
 135                                         e.printStackTrace();
 136                                 }
 137                         }
 138                 } catch (SQLException e) {
 139                         logger.error("Error in BerlinModleTaxonRelationImport.makeClassifications: " + e.getMessage());
 140                         throw e;
 141                 }
 142                 logger.info("end make classification ...");
 143
 144                 return;
 145         }
 146
 147         /**
 148          * @return
 149          * @throws SQLException
 150          */
 151         private Set<String> getTreeReferenceIdSet(Source source) throws SQLException {
 152                 Set<String> result = new HashSet<String>();
 153                 ResultSet rs = source.getResultSet(getClassificationQuery()) ;
 154                 while (rs.next()){
 155                         Object id = rs.getObject("PTRefFk");
 156                         result.add(String.valueOf(id));
 157                 }
 158                 return result;
 159         }
 160
 161         /**
 162          * @return
 163          */
 164         private String getClassificationQuery() {
 165                 String strQuery = "SELECT PTaxon.PTRefFk, Reference.RefCache " +
 166                                                 " FROM RelPTaxon INNER JOIN " +
 167                                                         " PTaxon AS PTaxon ON RelPTaxon.PTNameFk2 = PTaxon.PTNameFk AND RelPTaxon.PTRefFk2 = PTaxon.PTRefFk INNER JOIN " +
 168                                                         " Reference ON PTaxon.PTRefFk = Reference.RefId " +
 169                                                 " WHERE (RelPTaxon.RelQualifierFk = 1) " +
 170                                                 " GROUP BY PTaxon.PTRefFk, Reference.RefCache ";
 171                 return strQuery;
 172         }
 173
 174
 175         /* (non-Javadoc)
 176          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getRecordQuery(eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportConfigurator)
 177          */
 178         @Override
 179         protected String getRecordQuery(BerlinModelImportConfigurator config) {
 180                 String strQuery =
 181                         " SELECT RelPTaxon.*, FromTaxon.RIdentifier as taxon1Id, ToTaxon.RIdentifier as taxon2Id, ToTaxon.PTRefFk as treeRefFk, q.is_concept_relation " +
 182                         " FROM PTaxon as FromTaxon " +
 183                 " INNER JOIN RelPTaxon ON FromTaxon.PTNameFk = RelPTaxon.PTNameFk1 AND FromTaxon.PTRefFk = RelPTaxon.PTRefFk1 " +
 184                 " INNER JOIN PTaxon AS ToTaxon ON RelPTaxon.PTNameFk2 = ToTaxon.PTNameFk AND RelPTaxon.PTRefFk2 = ToTaxon.PTRefFk " +
 185                 " INNER JOIN RelPTQualifier q ON q.RelPTQualifierId = RelPTaxon.RelQualifierFk " +
 186             " WHERE RelPTaxon.RelPTaxonId IN ("+ID_LIST_TOKEN+") ";
 187                 return strQuery;
 188         }
 189
 190         /* (non-Javadoc)
 191          * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#doPartition(eu.etaxonomy.cdm.io.berlinModel.in.ResultSetPartitioner, eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState)
 192          */
 193         public boolean doPartition(ResultSetPartitioner partitioner, BerlinModelImportState state) {
 194                 boolean success = true ;
 195                 BerlinModelImportConfigurator config = state.getConfig();
 196                 Set<TaxonBase> taxaToSave = new HashSet<TaxonBase>();
 197                 Map<String, TaxonBase> taxonMap = (Map<String, TaxonBase>) partitioner.getObjectMap(BerlinModelTaxonImport.NAMESPACE);
 198                 Map<Integer, Classification> classificationMap = new HashMap<Integer, Classification>();
 199                 Map<String, Reference> biblioRefMap = (Map<String, Reference>) partitioner.getObjectMap(BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE);
 200                 Map<String, Reference> nomRefMap = (Map<String, Reference>) partitioner.getObjectMap(BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE);
 201
 202                 ResultSet rs = partitioner.getResultSet();
 203
 204                 try{
 205                         int i = 0;
 206                         //for each reference
 207                         while (rs.next()){
 208
 209                                 if ((i++ % modCount) == 0 && i!= 1 ){ logger.info("RelPTaxa handled: " + (i-1));}
 210
 211                                 int relPTaxonId = rs.getInt("RelPTaxonId");
 212                                 try {
 213                                         int taxon1Id = rs.getInt("taxon1Id");
 214                                         int taxon2Id = rs.getInt("taxon2Id");
 215                                         Object relRefFkObj = rs.getObject("relRefFk");
 216                                         int treeRefFk = rs.getInt("treeRefFk");
 217                                         int relQualifierFk = rs.getInt("relQualifierFk");
 218                                         String notes = rs.getString("notes");
 219                                         boolean isConceptRelationship = rs.getBoolean("is_concept_relation");
 220
 221                                         TaxonBase taxon1 = taxonMap.get(String.valueOf(taxon1Id));
 222                                         TaxonBase taxon2 = taxonMap.get(String.valueOf(taxon2Id));
 223
 224                                         String refFk = String.valueOf(relRefFkObj);
 225                                         Reference citation = getReferenceOnlyFromMaps(biblioRefMap,     nomRefMap, refFk);
 226
 227                                         String microcitation = null; //does not exist in RelPTaxon
 228
 229                                         if (taxon2 != null && taxon1 != null){
 230                                                 if (!(taxon2 instanceof Taxon)){
 231                                                         logger.error("TaxonBase (ID = " + taxon2.getId()+ ", RIdentifier = " + taxon2Id + ") can't be casted to Taxon");
 232                                                         success = false;
 233                                                         continue;
 234                                                 }
 235                                                 AnnotatableEntity taxonRelationship = null;
 236                                                 Taxon toTaxon = (Taxon)taxon2;
 237                                                 if (isTaxonRelationship(relQualifierFk)){
 238                                                         if (!(taxon1 instanceof Taxon)){
 239                                                                 logger.error("TaxonBase (ID = " + taxon1.getId()+ ", RIdentifier = " + taxon1Id + ") can't be casted to Taxon");
 240                                                                 success = false;
 241                                                                 continue;
 242                                                         }
 243                                                         Taxon fromTaxon = (Taxon)taxon1;
 244                                                         if (relQualifierFk == TAX_REL_IS_INCLUDED_IN){
 245                                                                 taxonRelationship = makeTaxonomicallyIncluded(state, classificationMap, treeRefFk, fromTaxon, toTaxon, citation, microcitation);
 246                                                         }else if (relQualifierFk == TAX_REL_IS_MISAPPLIED_NAME_OF){
 247                                                                  taxonRelationship = toTaxon.addMisappliedName(fromTaxon, citation, microcitation);
 248                                                         }
 249                                                 }else if (isSynonymRelationship(relQualifierFk)){
 250                                                         if (!(taxon1 instanceof Synonym)){
 251                                                                 logger.warn("Validated: Taxon (ID = " + taxon1.getId()+ ", RIdentifier = " + taxon1Id + ") can't be casted to Synonym");
 252                                                                 success = false;
 253                                                                 continue;
 254                                                         }
 255                                                         Synonym synonym = (Synonym)taxon1;
 256                                                         SynonymRelationship synRel = getSynRel(relQualifierFk, toTaxon, synonym, citation, microcitation);
 257                                                         taxonRelationship = synRel;
 258
 259                                                         if (relQualifierFk == TAX_REL_IS_SYNONYM_OF ||
 260                                                                         relQualifierFk == TAX_REL_IS_HOMOTYPIC_SYNONYM_OF ||
 261                                                                         relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF){
 262                                                                 addProParteAndPartial(synRel, synonym, config);
 263                                                         }else if (relQualifierFk == TAX_REL_IS_PROPARTE_SYN_OF ||
 264                                                                         relQualifierFk == TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF ||
 265                                                                         relQualifierFk == TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF ){
 266                                                                         synRel.setProParte(true);
 267                                                         }else if(relQualifierFk == TAX_REL_IS_PARTIAL_SYN_OF ||
 268                                                                         relQualifierFk == TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF ||
 269                                                                         relQualifierFk == TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF ){
 270                                                                         synRel.setPartial(true);
 271                                                         }else{
 272                                                                 success = false;
 273                                                                 logger.warn("Proparte/Partial not yet implemented for TaxonRelationShipType " + relQualifierFk);
 274                                                         }
 275                                                 }else if (isConceptRelationship){
 276                                                         ResultWrapper<Boolean> isInverse = new ResultWrapper<Boolean>();
 277                                                         try {
 278                                                                 TaxonRelationshipType relType = BerlinModelTransformer.taxonRelId2TaxonRelType(relQualifierFk, isInverse);
 279                                                                 if (! (taxon1 instanceof Taxon)){
 280                                                                         success = false;
 281                                                                         logger.error("TaxonBase (ID = " + taxon1.getId()+ ", RIdentifier = " + taxon1Id + ") can't be casted to Taxon");
 282                                                                 }else{
 283                                                                         Taxon fromTaxon = (Taxon)taxon1;
 284                                                                         taxonRelationship = fromTaxon.addTaxonRelation(toTaxon, relType, citation, microcitation);
 285                                                                 }
 286                                                         } catch (UnknownCdmTypeException e) {
 287                                                                 //TODO other relationships
 288                                                                 logger.warn("TaxonRelationShipType " + relQualifierFk + " (conceptRelationship) not yet implemented");
 289                                                                 success = false;
 290                                                         }
 291                                                 }else {
 292                                                         //TODO
 293                                                         logger.warn("TaxonRelationShipType " + relQualifierFk + " not yet implemented");
 294                                                         success = false;
 295                                                 }
 296
 297                                                 doNotes(taxonRelationship, notes);
 298                                                 taxaToSave.add(taxon2);
 299
 300                                                 //TODO
 301                                                 //etc.
 302                                         }else{
 303                                                 //TODO
 304                                                 logger.warn("Taxa for RelPTaxon " + relPTaxonId + " do not exist in store");
 305                                                 success = false;
 306                                         }
 307                                 } catch (Exception e) {
 308                                         logger.error("Exception occurred when trying to handle taxon relationship " + relPTaxonId + ":" + e.getMessage());
 309 //                                      e.printStackTrace();
 310                                 }
 311                         }
 312                 }catch(SQLException e){
 313                         throw new RuntimeException(e);
 314                 }
 315                 logger.info("Taxa to save: " + taxaToSave.size());
 316                 partitioner.startDoSave();
 317                 getTaxonService().save(taxaToSave);
 318                 classificationMap = null;
 319                 taxaToSave = null;
 320
 321                         return success;
 322         }
 323
 324
 325         /* (non-Javadoc)
 326          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doInvoke(eu.etaxonomy.cdm.io.common.IImportConfigurator, eu.etaxonomy.cdm.api.application.CdmApplicationController, java.util.Map)
 327          */
 328         @Override
 329         protected void doInvoke(BerlinModelImportState state){
 330                 try {
 331                         makeClassifications(state);
 332                         super.doInvoke(state);
 333                         return;
 334                 } catch (SQLException e) {
 335                         throw new RuntimeException(e);
 336                 }
 337
 338         }
 339
 340
 341         /* (non-Javadoc)
 342          * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#getRelatedObjectsForPartition(java.sql.ResultSet)
 343          */
 344         public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition( ResultSet rs) {
 345                 String nameSpace;
 346                 Class cdmClass;
 347                 Set<String> idSet;
 348                 Map<Object, Map<String, ? extends CdmBase>> result = new HashMap<Object, Map<String, ? extends CdmBase>>();
 349
 350                 try{
 351                         Set<String> taxonIdSet = new HashSet<String>();
 352                         Set<String> referenceIdSet = new HashSet<String>();
 353 //                      Set<String> classificationIdSet = new HashSet<String>();
 354                         while (rs.next()){
 355                                 handleForeignKey(rs, taxonIdSet, "taxon1Id");
 356                                 handleForeignKey(rs, taxonIdSet, "taxon2Id");
 357 //                              handleForeignKey(rs, classificationIdSet, "treeRefFk");
 358                                 handleForeignKey(rs, referenceIdSet, "RelRefFk");
 359         }
 360
 361                         //taxon map
 362                         nameSpace = BerlinModelTaxonImport.NAMESPACE;
 363                         cdmClass = TaxonBase.class;
 364                         idSet = taxonIdSet;
 365                         Map<String, TaxonBase> taxonMap = (Map<String, TaxonBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 366                         result.put(nameSpace, taxonMap);
 367
 368 //                      //tree map
 369 //                      nameSpace = "Classification";
 370 //                      cdmClass = Classification.class;
 371 //                      idSet = classificationIdSet;
 372 //                      Map<String, Classification> treeMap = (Map<String, Classification>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 373 //                      result.put(cdmClass, treeMap);
 374 //                      Set<UUID> treeUuidSet = state
 375 //                      getClassificationService().find(uuidSet);
 376 //
 377
 378                         //nom reference map
 379                         nameSpace = BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE;
 380                         cdmClass = Reference.class;
 381                         idSet = referenceIdSet;
 382                         Map<String, Reference> nomReferenceMap = (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 383                         result.put(nameSpace, nomReferenceMap);
 384
 385                         //biblio reference map
 386                         nameSpace = BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE;
 387                         cdmClass = Reference.class;
 388                         idSet = referenceIdSet;
 389                         Map<String, Reference> biblioReferenceMap = (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 390                         result.put(nameSpace, biblioReferenceMap);
 391
 392                 } catch (SQLException e) {
 393                         throw new RuntimeException(e);
 394                 }
 395                 return result;
 396         }
 397
 398         private SynonymRelationship getSynRel (int relQualifierFk, Taxon toTaxon, Synonym synonym, Reference citation, String microcitation){
 399                 SynonymRelationship result;
 400                 if (relQualifierFk == TAX_REL_IS_HOMOTYPIC_SYNONYM_OF ||
 401                                 relQualifierFk == TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF ||
 402                                 relQualifierFk == TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF){
 403                         result = toTaxon.addHomotypicSynonym(synonym, citation, microcitation);
 404                 }else if (relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF ||
 405                                 relQualifierFk == TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF ||
 406                                 relQualifierFk == TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF){
 407                         result = toTaxon.addSynonym(synonym, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF(), citation, microcitation);
 408                 }else if (relQualifierFk == TAX_REL_IS_SYNONYM_OF ||
 409                                 relQualifierFk == TAX_REL_IS_PROPARTE_SYN_OF ||
 410                                 relQualifierFk == TAX_REL_IS_PARTIAL_SYN_OF){
 411                         result = toTaxon.addSynonym(synonym, SynonymRelationshipType.SYNONYM_OF(), citation, microcitation);
 412                 }else{
 413                         logger.warn("SynonymyRelationShipType could not be defined for relQualifierFk " + relQualifierFk + ". 'Unknown'-Type taken instead.");
 414                         result = toTaxon.addSynonym(synonym, SynonymRelationshipType.SYNONYM_OF(), citation, microcitation);
 415                 }
 416                 return result;
 417
 418         }
 419
 420         private  boolean isSynonymRelationship(int relQualifierFk){
 421                 if (relQualifierFk == TAX_REL_IS_SYNONYM_OF ||
 422                         relQualifierFk == TAX_REL_IS_HOMOTYPIC_SYNONYM_OF ||
 423                         relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF ||
 424                         relQualifierFk == TAX_REL_IS_PROPARTE_SYN_OF ||
 425                         relQualifierFk == TAX_REL_IS_PARTIAL_SYN_OF ||
 426                         relQualifierFk == TAX_REL_IS_PROPARTE_HOMOTYPIC_SYNONYM_OF ||
 427                         relQualifierFk == TAX_REL_IS_PROPARTE_HETEROTYPIC_SYNONYM_OF ||
 428                         relQualifierFk == TAX_REL_IS_PARTIAL_HOMOTYPIC_SYNONYM_OF ||
 429                         relQualifierFk == TAX_REL_IS_PARTIAL_HETEROTYPIC_SYNONYM_OF
 430                 ){
 431                         return true;
 432                 }else{
 433                         return false;
 434                 }
 435         }
 436
 437         private  boolean isTaxonRelationship(int relQualifierFk){
 438                 if (relQualifierFk == TAX_REL_IS_INCLUDED_IN ||
 439                 relQualifierFk == TAX_REL_IS_MISAPPLIED_NAME_OF){
 440                         return true;
 441                 }else{
 442                         return false;
 443                 }
 444         }
 445
 446         private void addProParteAndPartial(SynonymRelationship synRel, Synonym synonym, BerlinModelImportConfigurator bmiConfig){
 447                 if (bmiConfig.isPartialSynonym(synonym)){
 448                         synRel.setPartial(true);
 449                 }
 450                 if (bmiConfig.isProParteSynonym(synonym)){
 451                         synRel.setProParte(true);
 452                 }
 453         }
 454
 455         private TaxonNode makeTaxonomicallyIncluded(BerlinModelImportState state, Map<Integer, Classification> classificationMap, int treeRefFk, Taxon child, Taxon parent, Reference citation, String microCitation){
 456                 Classification tree = classificationMap.get(treeRefFk);
 457                 if (tree == null){
 458                         UUID treeUuid = state.getTreeUuidByIntTreeKey(treeRefFk);
 459                         tree = getClassificationService().find(treeUuid);
 460                         classificationMap.put(treeRefFk, tree);
 461                 }
 462                 if (tree == null){
 463                         throw new IllegalStateException("Tree for ToTaxon reference does not exist.");
 464                 }
 465                 return tree.addParentChild(parent, child, citation, microCitation);
 466         }
 467
 468
 469         /* (non-Javadoc)
 470          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IoStateBase)
 471          */
 472         @Override
 473         protected boolean doCheck(BerlinModelImportState state){
 474                 IOValidator<BerlinModelImportState> validator = new BerlinModelTaxonRelationImportValidator();
 475                 return validator.validate(state);
 476         }
 477
 478
 479         /* (non-Javadoc)
 480          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getTableName()
 481          */
 482         @Override
 483         protected String getTableName() {
 484                 return dbTableName;
 485         }
 486
 487         /* (non-Javadoc)
 488          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getPluralString()
 489          */
 490         @Override
 491         public String getPluralString() {
 492                 return pluralString;
 493         }
 494
 495         /* (non-Javadoc)
 496          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IImportConfigurator)
 497          */
 498         protected boolean isIgnore(BerlinModelImportState state){
 499                 return ! state.getConfig().isDoRelTaxa();
 500         }
 501
 502
 503 }