cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/berlinModel/in/BerlinModelTaxonNameImport.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 java.sql.ResultSet;
  13 import java.sql.SQLException;
  14 import java.util.HashMap;
  15 import java.util.HashSet;
  16 import java.util.Map;
  17 import java.util.Set;
  18 import java.util.UUID;
  19
  20 import javax.mail.MethodNotSupportedException;
  21
  22 import org.apache.log4j.Logger;
  23 import org.springframework.stereotype.Component;
  24
  25 import eu.etaxonomy.cdm.common.CdmUtils;
  26 import eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer;
  27 import eu.etaxonomy.cdm.io.berlinModel.in.validation.BerlinModelTaxonNameImportValidator;
  28 import eu.etaxonomy.cdm.io.common.IImportConfigurator;
  29 import eu.etaxonomy.cdm.io.common.IOValidator;
  30 import eu.etaxonomy.cdm.io.common.ImportHelper;
  31 import eu.etaxonomy.cdm.io.common.ResultSetPartitioner;
  32 import eu.etaxonomy.cdm.io.common.Source;
  33 import eu.etaxonomy.cdm.model.agent.Person;
  34 import eu.etaxonomy.cdm.model.agent.Team;
  35 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  36 import eu.etaxonomy.cdm.model.common.CdmBase;
  37 import eu.etaxonomy.cdm.model.common.Extension;
  38 import eu.etaxonomy.cdm.model.common.ExtensionType;
  39 import eu.etaxonomy.cdm.model.common.Language;
  40 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  41 import eu.etaxonomy.cdm.model.common.Representation;
  42 import eu.etaxonomy.cdm.model.name.BotanicalName;
  43 import eu.etaxonomy.cdm.model.name.CultivarPlantName;
  44 import eu.etaxonomy.cdm.model.name.NonViralName;
  45 import eu.etaxonomy.cdm.model.name.Rank;
  46 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  47 import eu.etaxonomy.cdm.model.name.ZoologicalName;
  48 import eu.etaxonomy.cdm.model.reference.INomenclaturalReference;
  49 import eu.etaxonomy.cdm.model.reference.Reference;
  50 import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
  51
  52 /**
  53  * @author a.mueller
  54  * @created 20.03.2008
  55  * @version 1.0
  56  */
  57 @Component
  58 public class BerlinModelTaxonNameImport extends BerlinModelImportBase {
  59         private static final boolean BLANK_TO_NULL = true;
  60
  61         private static final Logger logger = Logger.getLogger(BerlinModelTaxonNameImport.class);
  62
  63         public static final String NAMESPACE = "TaxonName";
  64
  65         public static final UUID SOURCE_ACC_UUID = UUID.fromString("c3959b4f-d876-4b7a-a739-9260f4cafd1c");
  66
  67         private static int modCount = 5000;
  68         private static final String pluralString = "TaxonNames";
  69         private static final String dbTableName = "Name";
  70
  71
  72         public BerlinModelTaxonNameImport(){
  73                 super();
  74         }
  75
  76
  77         /* (non-Javadoc)
  78          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getIdQuery(eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState)
  79          */
  80         @Override
  81         protected String getIdQuery(BerlinModelImportState state) {
  82                 if (state.getConfig().getNameIdTable()==null ){
  83                         return super.getIdQuery(state);
  84                 }else{
  85                         return "SELECT nameId FROM " + state.getConfig().getNameIdTable() + "";
  86                 }
  87         }
  88
  89
  90         /* (non-Javadoc)
  91          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getRecordQuery()
  92          */
  93         @Override
  94         protected String getRecordQuery(BerlinModelImportConfigurator config) {
  95                 Source source = config.getSource();
  96
  97                         String facultativCols = "";
  98                         String strFacTable = "RefDetail";
  99                         String strFacColumn = "IdInSource";
 100                         String strColAlias = null;
 101                         if (checkSqlServerColumnExists(source, strFacTable, strFacColumn)){
 102                                 facultativCols +=  ", " + strFacTable + "." + strFacColumn ;
 103                                 if (! CdmUtils.Nz(strColAlias).equals("") ){
 104                                         facultativCols += " AS " + strColAlias;
 105                                 }
 106                         }
 107
 108                 String strRecordQuery =
 109                                         "SELECT Name.* , RefDetail.RefDetailId, RefDetail.RefFk, " +
 110                                 " RefDetail.FullRefCache, RefDetail.FullNomRefCache, RefDetail.PreliminaryFlag AS RefDetailPrelim, RefDetail.Details, " +
 111                                 " RefDetail.SecondarySources, Rank.RankAbbrev, Rank.Rank " +
 112                                 facultativCols +
 113                     " FROM Name LEFT OUTER JOIN RefDetail ON Name.NomRefDetailFk = RefDetail.RefDetailId AND  " +
 114                         " Name.NomRefFk = RefDetail.RefFk " +
 115                         " LEFT OUTER JOIN Rank ON Name.RankFk = Rank.rankID " +
 116                 " WHERE name.nameId IN ("+ID_LIST_TOKEN+") ";
 117                                         //strQuery += " AND RefDetail.PreliminaryFlag = 1 ";
 118                                         //strQuery += " AND Name.Created_When > '03.03.2004' ";
 119                 return strRecordQuery +  "";
 120         }
 121
 122
 123
 124         @Override
 125         protected void doInvoke(BerlinModelImportState state) {
 126                 //update rank labels if necessary
 127                 String strAbbrev = state.getConfig().getInfrGenericRankAbbrev();
 128                 Rank rank = Rank.INFRAGENERICTAXON();
 129                 testRankAbbrev(strAbbrev, rank);
 130
 131                 strAbbrev = state.getConfig().getInfrSpecificRankAbbrev();
 132                 rank = Rank.INFRASPECIFICTAXON();
 133                 testRankAbbrev(strAbbrev, rank);
 134
 135                 super.doInvoke(state);
 136         }
 137
 138         private void testRankAbbrev(String strAbbrev, Rank rank) {
 139                 if (strAbbrev != null){
 140                         Representation rep = rank.getRepresentation(Language.ENGLISH());
 141                         rep.setAbbreviatedLabel(strAbbrev);
 142                         getTermService().saveOrUpdate(rank);
 143                 }
 144         }
 145
 146
 147         /* (non-Javadoc)
 148          * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#doPartition(eu.etaxonomy.cdm.io.berlinModel.in.ResultSetPartitioner, eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState)
 149          */
 150         public boolean doPartition(ResultSetPartitioner partitioner, BerlinModelImportState state) {
 151                 String dbAttrName;
 152                 String cdmAttrName;
 153                 boolean success = true ;
 154                 BerlinModelImportConfigurator config = state.getConfig();
 155                 Set<TaxonNameBase> namesToSave = new HashSet<TaxonNameBase>();
 156                 Map<String, Team> teamMap = (Map<String, Team>) partitioner.getObjectMap(BerlinModelAuthorTeamImport.NAMESPACE);
 157
 158                 ResultSet rs = partitioner.getResultSet();
 159
 160                 try {
 161                         int i = 0;
 162                         //for each reference
 163                         while (rs.next()){
 164
 165                                 if ((i++ % modCount) == 0 && i != 1 ){ logger.info("Names handled: " + (i-1));}
 166
 167                                 //create TaxonName element
 168                                 int nameId = rs.getInt("nameId");
 169                                 Object authorFk = rs.getObject("AuthorTeamFk");
 170                                 Object exAuthorFk = rs.getObject("ExAuthorTeamFk");
 171                                 Object basAuthorFk = rs.getObject("BasAuthorTeamFk");
 172                                 Object exBasAuthorFk = rs.getObject("ExBasAuthorTeamFk");
 173                                 String strCultivarGroupName = rs.getString("CultivarGroupName");
 174                                 String strCultivarName = rs.getString("CultivarName");
 175                                 String nameCache = rs.getString("NameCache");
 176                                 String fullNameCache = rs.getString("FullNameCache");
 177
 178                                 try {
 179
 180                                         //define rank
 181                                         boolean useUnknownRank = true;
 182                                         Rank rank = BerlinModelTransformer.rankId2Rank(rs, useUnknownRank, config.isSwitchSpeciesGroup());
 183
 184                                         if (rank == null || rank.equals(Rank.UNKNOWN_RANK()) || rank.equals(Rank.INFRASPECIFICTAXON())){
 185                                                 rank = handleProlesAndRaceSublusus(state, rs, rank);
 186                                         }
 187
 188                                         if (rank.getId() == 0){
 189                                                 getTermService().save(rank);
 190                                                 logger.warn("Rank did not yet exist: " +  rank.getTitleCache());
 191                                         }
 192
 193                                         //create TaxonNameBase
 194                                         TaxonNameBase taxonNameBase;
 195                                         if (config.getNomenclaturalCode() != null){
 196                                                 taxonNameBase = config.getNomenclaturalCode().getNewTaxonNameInstance(rank);
 197                                                 //check cultivar
 198                                                 if (taxonNameBase instanceof BotanicalName){
 199                                                         if (CdmUtils.isNotEmpty(strCultivarGroupName) && CdmUtils.isNotEmpty(strCultivarName)){
 200                                                                 taxonNameBase = CultivarPlantName.NewInstance(rank);
 201                                                         }
 202                                                 }
 203                                         }else{
 204                                                 taxonNameBase = NonViralName.NewInstance(rank);
 205                                         }
 206
 207                                         if (rank == null){
 208                                                 //TODO rank should never be null or a more sophisticated algorithm has to be implemented for genus/supraGenericName
 209                                                 logger.warn("Rank is null. Genus epethiton was imported. May be wrong");
 210                                                 success = false;
 211                                         }
 212
 213                                         //epithets
 214                                         if (rank != null && rank.isSupraGeneric()){
 215                                                 dbAttrName = "supraGenericName";
 216                                         }else{
 217                                                 dbAttrName = "genus";
 218                                         }
 219                                         cdmAttrName = "genusOrUninomial";
 220                                         success &= ImportHelper.addStringValue(rs, taxonNameBase, dbAttrName, cdmAttrName, BLANK_TO_NULL);
 221
 222                                         dbAttrName = "genusSubdivisionEpi";
 223                                         cdmAttrName = "infraGenericEpithet";
 224                                         success &= ImportHelper.addStringValue(rs, taxonNameBase, dbAttrName, cdmAttrName, BLANK_TO_NULL);
 225
 226                                         dbAttrName = "speciesEpi";
 227                                         cdmAttrName = "specificEpithet";
 228                                         success &= ImportHelper.addStringValue(rs, taxonNameBase, dbAttrName, cdmAttrName, BLANK_TO_NULL);
 229
 230
 231                                         dbAttrName = "infraSpeciesEpi";
 232                                         cdmAttrName = "infraSpecificEpithet";
 233                                         success &= ImportHelper.addStringValue(rs, taxonNameBase, dbAttrName, cdmAttrName, BLANK_TO_NULL);
 234
 235                                         dbAttrName = "unnamedNamePhrase";
 236                                         cdmAttrName = "appendedPhrase";
 237                                         success &= ImportHelper.addStringValue(rs, taxonNameBase, dbAttrName, cdmAttrName, BLANK_TO_NULL);
 238
 239                                         //Details
 240                                         dbAttrName = "details";
 241                                         cdmAttrName = "nomenclaturalMicroReference";
 242                                         success &= ImportHelper.addStringValue(rs, taxonNameBase, dbAttrName, cdmAttrName, BLANK_TO_NULL);
 243
 244                                         //nomRef
 245                                         success &= makeNomenclaturalReference(config, taxonNameBase, nameId, rs, partitioner);
 246
 247                                         //Source_Acc
 248                                         boolean colExists = true;
 249                                         try {
 250                                                 colExists = state.getConfig().getSource().checkColumnExists("Name", "Source_Acc");
 251                                         } catch (MethodNotSupportedException e) {
 252                                                 logger.debug("Source does not support 'checkColumnExists'");
 253                                         }
 254                                         if (colExists){
 255                                                 String sourceAcc = rs.getString("Source_Acc");
 256                                                 if (CdmUtils.isNotEmpty(sourceAcc)){
 257                                                         ExtensionType sourceAccExtensionType = getExtensionType(state, SOURCE_ACC_UUID, "Source_Acc","Source_Acc","Source_Acc");
 258                                                         Extension datesExtension = Extension.NewInstance(taxonNameBase, sourceAcc, sourceAccExtensionType);
 259                                                 }
 260                                         }
 261
 262                                         //created, notes
 263                                         boolean excludeUpdated = true;
 264                                         success &= doIdCreatedUpdatedNotes(state, taxonNameBase, rs, nameId, NAMESPACE, excludeUpdated);
 265
 266                                         //NonViralName
 267                                         if (taxonNameBase instanceof NonViralName){
 268                                                 NonViralName<?> nonViralName = (NonViralName<?>)taxonNameBase;
 269
 270                                                 //authorTeams
 271                                                 if (teamMap != null ){
 272                                                         nonViralName.setCombinationAuthorTeam(getAuthorTeam(teamMap, authorFk, nameId, config));
 273                                                         nonViralName.setExCombinationAuthorTeam(getAuthorTeam(teamMap, exAuthorFk, nameId, config));
 274                                                         nonViralName.setBasionymAuthorTeam(getAuthorTeam(teamMap, basAuthorFk, nameId, config));
 275                                                         nonViralName.setExBasionymAuthorTeam(getAuthorTeam(teamMap, exBasAuthorFk, nameId, config));
 276                                                 }else{
 277                                                         logger.warn("TeamMap is null");
 278                                                         success = false;
 279                                                 }
 280                                         }//nonviralName
 281
 282
 283
 284                                         //zoologicalName
 285                                         if (taxonNameBase instanceof ZoologicalName){
 286                                                 ZoologicalName zooName = (ZoologicalName)taxonNameBase;
 287                                                 makeZoologialName(rs, zooName, nameId);
 288                                         }
 289                                         //botanicalName
 290                                         else if (taxonNameBase instanceof BotanicalName){
 291                                                 BotanicalName botName = (BotanicalName)taxonNameBase;
 292                                                 success &= makeBotanicalNamePart(rs, botName) ;
 293
 294                                         }
 295
 296         //                              dbAttrName = "preliminaryFlag";
 297                                         Boolean preliminaryFlag = rs.getBoolean("PreliminaryFlag");
 298                                         Boolean hybridFormulaFlag = rs.getBoolean("HybridFormulaFlag");  //hybrid flag does not lead to cache update in Berlin Model
 299                                         if (preliminaryFlag == true || hybridFormulaFlag == true){
 300                                                 //Computes all caches and sets
 301                                                 taxonNameBase.setTitleCache(fullNameCache, true);
 302                                                 taxonNameBase.setFullTitleCache(taxonNameBase.getFullTitleCache(), true);
 303                                                 if (taxonNameBase instanceof NonViralName){
 304                                                         NonViralName<?> nvn = (NonViralName<?>)taxonNameBase;
 305                                                         nvn.setNameCache(nameCache, true);
 306                                                         nvn.setAuthorshipCache(nvn.getAuthorshipCache(), true);
 307                                                 }
 308                                         }
 309                                         namesToSave.add(taxonNameBase);
 310
 311                                 }
 312                                 catch (UnknownCdmTypeException e) {
 313                                         logger.warn("Name with id " + nameId + " has unknown rankId " + " and could not be saved.");
 314                                         success = false;
 315                                 }
 316
 317                         } //while rs.hasNext()
 318                 } catch (SQLException e) {
 319                         logger.error("SQLException:" +  e);
 320                         return false;
 321                 }
 322
 323
 324 //              logger.info( i + " names handled");
 325                 getNameService().save(namesToSave);
 326                 return success;
 327         }
 328
 329
 330         private Rank handleProlesAndRaceSublusus(BerlinModelImportState state, ResultSet rs, Rank rank) throws SQLException {
 331                 Rank result;
 332                 String rankAbbrev = rs.getString("RankAbbrev");
 333                 String rankStr = rs.getString("Rank");
 334                 if (CdmUtils.nullSafeEqual(rankAbbrev, "prol.") ){
 335                         result = getRank(state, BerlinModelTransformer.uuidRankProles, rankStr, "Rank Proles", rankAbbrev, CdmBase.deproxy(Rank.SPECIES().getVocabulary(), OrderedTermVocabulary.class), Rank.CONVAR());
 336                 }else if(CdmUtils.nullSafeEqual(rankAbbrev, "race")){
 337                         result = getRank(state, BerlinModelTransformer.uuidRankRace, rankStr, "Rank Race", rankAbbrev, CdmBase.deproxy(Rank.SPECIES().getVocabulary(), OrderedTermVocabulary.class), Rank.CONVAR());
 338                 }else if(CdmUtils.nullSafeEqual(rankAbbrev, "sublusus")){
 339                         result = getRank(state, BerlinModelTransformer.uuidRankSublusus, rankStr, "Rank Sublusus", rankAbbrev, CdmBase.deproxy(Rank.SPECIES().getVocabulary(), OrderedTermVocabulary.class), Rank.CONVAR());
 340                 }else{
 341                         result = rank;
 342                         logger.warn("Unhandled rank: " + rankAbbrev);
 343                 }
 344                 return result;
 345         }
 346
 347
 348         /* (non-Javadoc)
 349          * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#getRelatedObjectsForPartition(java.sql.ResultSet)
 350          */
 351         public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition(ResultSet rs) {
 352                 String nameSpace;
 353                 Class cdmClass;
 354                 Set<String> idSet;
 355
 356                 Map<Object, Map<String, ? extends CdmBase>> result = new HashMap<Object, Map<String, ? extends CdmBase>>();
 357
 358                 try{
 359                         Set<String> teamIdSet = new HashSet<String>();
 360                         Set<String> referenceIdSet = new HashSet<String>();
 361                         Set<String> refDetailIdSet = new HashSet<String>();
 362                         while (rs.next()){
 363                                 handleForeignKey(rs, teamIdSet, "AuthorTeamFk");
 364                                 handleForeignKey(rs, teamIdSet, "ExAuthorTeamFk");
 365                                 handleForeignKey(rs, teamIdSet, "BasAuthorTeamFk");
 366                                 handleForeignKey(rs, teamIdSet, "ExBasAuthorTeamFk");
 367                                 handleForeignKey(rs, referenceIdSet, "nomRefFk");
 368                                 handleForeignKey(rs, refDetailIdSet, "nomRefDetailFk");
 369                         }
 370
 371                         //team map
 372                         nameSpace = BerlinModelAuthorTeamImport.NAMESPACE;
 373                         cdmClass = Team.class;
 374                         idSet = teamIdSet;
 375                         Map<String, Person> teamMap = (Map<String, Person>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 376                         result.put(nameSpace, teamMap);
 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                         //nom refDetail map
 393                         nameSpace = BerlinModelRefDetailImport.NOM_REFDETAIL_NAMESPACE;
 394                         cdmClass = Reference.class;
 395                         idSet = refDetailIdSet;
 396                         Map<String, Reference> nomRefDetailMap= (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 397                         result.put(nameSpace, nomRefDetailMap);
 398
 399                         //biblio refDetail map
 400                         nameSpace = BerlinModelRefDetailImport.BIBLIO_REFDETAIL_NAMESPACE;
 401                         cdmClass = Reference.class;
 402                         idSet = refDetailIdSet;
 403                         Map<String, Reference> biblioRefDetailMap= (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 404                         result.put(nameSpace, biblioRefDetailMap);
 405
 406                 } catch (SQLException e) {
 407                         throw new RuntimeException(e);
 408                 }
 409                 return result;
 410         }
 411
 412         private boolean makeZoologialName(ResultSet rs, ZoologicalName zooName, int nameId)
 413                                         throws SQLException{
 414                 boolean success = true;
 415                 //publicationYear
 416                 String authorTeamYear = rs.getString("authorTeamYear");
 417                 try {
 418                         if (! "".equals(CdmUtils.Nz(authorTeamYear).trim())){
 419                                 Integer publicationYear  = Integer.valueOf(authorTeamYear.trim());
 420                                 zooName.setPublicationYear(publicationYear);
 421                         }
 422                 } catch (NumberFormatException e) {
 423                         logger.warn("authorTeamYear could not be parsed for taxonName: "+ nameId);
 424                 }
 425                 //original publication year
 426                 String basAuthorTeamYear = rs.getString("basAuthorTeamYear");
 427                 try {
 428                         if (! "".equals(CdmUtils.Nz(basAuthorTeamYear).trim())){
 429                                 Integer OriginalPublicationYear  = Integer.valueOf(basAuthorTeamYear.trim());
 430                                 zooName.setOriginalPublicationYear(OriginalPublicationYear);
 431                         }
 432                 } catch (NumberFormatException e) {
 433                         logger.warn("basAuthorTeamYear could not be parsed for taxonName: "+ nameId);
 434                 }
 435                 return success;
 436         }
 437
 438         private boolean makeBotanicalNamePart(ResultSet rs, BotanicalName botanicalName)throws SQLException{
 439                 boolean success = true;
 440                 String dbAttrName;
 441                 String cdmAttrName;
 442
 443                 dbAttrName = "HybridFormulaFlag";
 444                 cdmAttrName = "isHybridFormula";
 445                 success &= ImportHelper.addBooleanValue(rs, botanicalName, dbAttrName, cdmAttrName);
 446
 447                 dbAttrName = "MonomHybFlag";
 448                 cdmAttrName = "isMonomHybrid";
 449                 success &= ImportHelper.addBooleanValue(rs, botanicalName, dbAttrName, cdmAttrName);
 450
 451                 dbAttrName = "BinomHybFlag";
 452                 cdmAttrName = "isBinomHybrid";
 453                 success &= ImportHelper.addBooleanValue(rs, botanicalName, dbAttrName, cdmAttrName);
 454
 455                 dbAttrName = "TrinomHybFlag";
 456                 cdmAttrName = "isTrinomHybrid";
 457                 success &= ImportHelper.addBooleanValue(rs, botanicalName, dbAttrName, cdmAttrName);
 458
 459                 try {
 460                         String strCultivarGroupName = rs.getString("CultivarGroupName");
 461                         String strCultivarName = rs.getString("CultivarName");
 462                         if (botanicalName instanceof CultivarPlantName){
 463                                 CultivarPlantName cultivarName = (CultivarPlantName)botanicalName;
 464                                 String concatCultivarName = CdmUtils.concat("-", strCultivarName, strCultivarGroupName);
 465                                 if (CdmUtils.isNotEmpty(strCultivarGroupName) && CdmUtils.isNotEmpty(strCultivarName)){
 466                                         logger.warn("CDM does not support cultivarGroupName and CultivarName together: " + concatCultivarName);
 467                                 }
 468                                 cultivarName.setCultivarName(strCultivarGroupName);
 469                         }
 470                 } catch (SQLException e) {
 471                         throw e;
 472                 }
 473                 return success;
 474         }
 475
 476
 477         private boolean makeNomenclaturalReference(IImportConfigurator config, TaxonNameBase taxonNameBase,
 478                                         int nameId, ResultSet rs, ResultSetPartitioner partitioner) throws SQLException{
 479                 Map<String, Reference> biblioRefMap = partitioner.getObjectMap(BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE);
 480                 Map<String, Reference> nomRefMap = partitioner.getObjectMap(BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE);
 481                 Map<String, Reference> biblioRefDetailMap = partitioner.getObjectMap(BerlinModelRefDetailImport.BIBLIO_REFDETAIL_NAMESPACE);
 482                 Map<String, Reference> nomRefDetailMap = partitioner.getObjectMap(BerlinModelRefDetailImport.NOM_REFDETAIL_NAMESPACE);
 483
 484                 Object nomRefFkObj = rs.getObject("NomRefFk");
 485                 Object nomRefDetailFkObj = rs.getObject("NomRefDetailFk");
 486                 boolean refDetailPrelim = rs.getBoolean("RefDetailPrelim");
 487
 488                 boolean success = true;
 489                 //nomenclatural Reference
 490                 if (biblioRefMap != null){
 491                         if (nomRefFkObj != null){
 492                                 String nomRefFk = String.valueOf(nomRefFkObj);
 493                                 String nomRefDetailFk = String.valueOf(nomRefDetailFkObj);
 494                                 //get nomRef
 495                                 Reference nomReference =
 496                                         getReferenceFromMaps(nomRefDetailMap, biblioRefDetailMap,
 497                                                         nomRefMap, biblioRefMap, nomRefDetailFk, nomRefFk);
 498
 499
 500                                 //setNomRef
 501                                 if (nomReference == null ){
 502                                         //TODO
 503                                         if (! config.isIgnoreNull()){
 504                                                 logger.warn("Nomenclatural reference (nomRefFk = " + nomRefFk + ") for TaxonName (nameId = " + nameId + ")"+
 505                                                         " was not found in reference store. Nomenclatural reference was not set!!");
 506                                         }
 507                                 }else{
 508                                         if (! INomenclaturalReference.class.isAssignableFrom(nomReference.getClass())){
 509                                                 logger.warn("Nomenclatural reference (nomRefFk = " + nomRefFk + ") for TaxonName (nameId = " + nameId + ")"+
 510                                                                 " is not assignable from INomenclaturalReference. (Class = " + nomReference.getClass()+ ")");
 511                                         }
 512                                         nomReference.setNomenclaturallyRelevant(true);
 513                                         taxonNameBase.setNomenclaturalReference(nomReference);
 514                                 }
 515                         }
 516                 }
 517                 return success;
 518         }
 519
 520         private static TeamOrPersonBase getAuthorTeam(Map<String, Team> teamMap, Object teamIdObject, int nameId, BerlinModelImportConfigurator bmiConfig){
 521                 if (teamIdObject == null){
 522                         return null;
 523                 }else {
 524                         String teamId = String.valueOf(teamIdObject);
 525                         TeamOrPersonBase author = teamMap.get(teamId);
 526                         if (author == null){
 527                                 //TODO
 528                                 if (!bmiConfig.isIgnoreNull() && ! (teamId.equals(0) && bmiConfig.isIgnore0AuthorTeam()) ){
 529                                         logger.warn("AuthorTeam (teamId = " + teamId + ") for TaxonName (nameId = " + nameId + ")"+
 530                                 " was not found in authorTeam store. Relation was not set!!");}
 531                                 return null;
 532                         }else{
 533                                 return author;
 534                         }
 535                 }
 536         }
 537
 538         /* (non-Javadoc)
 539          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IImportConfigurator)
 540          */
 541         @Override
 542         protected boolean doCheck(BerlinModelImportState state){
 543                 IOValidator<BerlinModelImportState> validator = new BerlinModelTaxonNameImportValidator();
 544                 return validator.validate(state);
 545         }
 546
 547         /* (non-Javadoc)
 548          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getTableName()
 549          */
 550         @Override
 551         protected String getTableName() {
 552                 return dbTableName;
 553         }
 554
 555         /* (non-Javadoc)
 556          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getPluralString()
 557          */
 558         @Override
 559         public String getPluralString() {
 560                 return pluralString;
 561         }
 562
 563         /* (non-Javadoc)
 564          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IImportConfigurator)
 565          */
 566         protected boolean isIgnore(BerlinModelImportState state){
 567                 return ! state.getConfig().isDoTaxonNames();
 568         }
 569
 570
 571
 572
 573
 574
 575 //FOR FUTURE USE , DONT DELETE
 576 //      new CdmStringMapper("nameId", "nameId"),
 577 //      new CdmStringMapper("rankFk", "rankFk"),
 578 //      new CdmStringMapper("nameCache", "nameCache"),
 579 //      new CdmStringMapper("unnamedNamePhrase", "unnamedNamePhrase"),
 580 //      new CdmStringMapper("fullNameCache", "fullNameCache"),
 581 //      new CdmStringMapper("preliminaryFlag", "preliminaryFlag"),
 582 //      new CdmStringMapper("supragenericName", "supragenericName"),
 583 //      new CdmStringMapper("genus", "genus"),
 584 //      new CdmStringMapper("genusSubdivisionEpi", "genusSubdivisionEpi"),
 585 //      new CdmStringMapper("speciesEpi", "speciesEpi"),
 586 //      new CdmStringMapper("infraSpeciesEpi", "infraSpeciesEpi"),
 587 //      new CdmStringMapper("authorTeamFk", "authorTeamFk"),
 588 //      new CdmStringMapper("exAuthorTeamFk", "exAuthorTeamFk"),
 589 //      new CdmStringMapper("basAuthorTeamFk", "basAuthorTeamFk"),
 590 //      new CdmStringMapper("exBasAuthorTeamFk", "exBasAuthorTeamFk"),
 591 //      new CdmStringMapper("hybridFormulaFlag", "hybridFormulaFlag"),
 592 //      new CdmStringMapper("monomHybFlag", "monomHybFlag"),
 593 //      new CdmStringMapper("binomHybFlag", "binomHybFlag"),
 594 //      new CdmStringMapper("trinomHybFlag", "trinomHybFlag"),
 595 //      new CdmStringMapper("cultivarGroupName", "cultivarGroupName"),
 596 //      new CdmStringMapper("cultivarName", "cultivarName"),
 597 //      new CdmStringMapper("nomRefFk", "nomRefFk"),
 598 //      new CdmStringMapper("nomRefDetailFk", "nomRefDetailFk"),
 599 //      new CdmStringMapper("nameSourceRefFk", "nameSourceRefFk"),
 600 //      new CdmStringMapper("source_Acc", "source_Acc"),
 601 //      new CdmStringMapper("created_When", "created_When"),
 602 //      new CdmStringMapper("created_Who", "created_Who"),
 603 //      new CdmStringMapper("notes", "notes"),
 604 //      new CdmStringMapper("parsingComments", "parsingComments"),
 605 //      new CdmStringMapper("oldNomRefFk", "oldNomRefFk"),
 606 //      new CdmStringMapper("oldNomRefDetailFk", "oldNomRefDetailFk"),
 607 //      new CdmStringMapper("updated_Who", "updated_Who"),
 608 //      new CdmStringMapper("orthoProjection", "orthoProjection"),
 609
 610
 611 }