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