cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/berlinModel/BerlinModelTaxonIO.java

   1 /**
   2  *
   3  */
   4 package eu.etaxonomy.cdm.io.berlinModel;
   5
   6 import static eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer.*;
   7
   8 import java.sql.ResultSet;
   9 import java.sql.SQLException;
  10 import java.util.HashSet;
  11 import java.util.Map;
  12 import java.util.Set;
  13 import java.util.UUID;
  14
  15 import org.apache.log4j.Logger;
  16
  17 import eu.etaxonomy.cdm.api.application.CdmApplicationController;
  18 import eu.etaxonomy.cdm.api.service.INameService;
  19 import eu.etaxonomy.cdm.api.service.IReferenceService;
  20 import eu.etaxonomy.cdm.api.service.ITaxonService;
  21 import eu.etaxonomy.cdm.io.source.Source;
  22 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  23 import eu.etaxonomy.cdm.model.reference.ReferenceBase;
  24 import eu.etaxonomy.cdm.model.taxon.Synonym;
  25 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
  26 import eu.etaxonomy.cdm.model.taxon.Taxon;
  27 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  28 import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
  29
  30
  31 /**
  32  * @author a.mueller
  33  *
  34  */
  35 public class BerlinModelTaxonIO {
  36         private static final Logger logger = Logger.getLogger(BerlinModelTaxonIO.class);
  37
  38         private static int modCount = 30000;
  39
  40         public static boolean invoke(BerlinModelImportConfigurator bmiConfig, CdmApplicationController cdmApp,
  41                         MapWrapper<TaxonBase> taxonMap, MapWrapper<TaxonNameBase> taxonNameMap, MapWrapper<ReferenceBase> referenceMap){
  42                 Source source = bmiConfig.getSource();
  43                 String dbAttrName;
  44                 String cdmAttrName;
  45
  46                 logger.info("start makeTaxa ...");
  47
  48                 ITaxonService taxonService = cdmApp.getTaxonService();
  49                 boolean delete = bmiConfig.isDeleteAll();
  50
  51                 try {
  52                         //get data from database
  53                         String strQuery =
  54                                         " SELECT * " +
  55                                         " FROM PTaxon " +
  56                                         " WHERE (1=1)";
  57
  58                         ResultSet rs = source.getResultSet(strQuery) ;
  59
  60                         int i = 0;
  61                         //for each reference
  62                         while (rs.next()){
  63
  64                                 if ((i++ % modCount) == 0){ logger.info("PTaxa handled: " + (i-1));}
  65
  66                                 //create TaxonName element
  67                                 int taxonId = rs.getInt("RIdentifier");
  68                                 int statusFk = rs.getInt("statusFk");
  69
  70                                 int nameFk = rs.getInt("PTNameFk");
  71                                 int refFk = rs.getInt("PTRefFk");
  72                                 String doubtful = rs.getString("DoubtfulFlag");
  73
  74                                 TaxonNameBase taxonName = null;
  75                                 if (taxonNameMap != null){
  76                                         taxonName  = taxonNameMap.get(nameFk);
  77                                 }
  78
  79                                 ReferenceBase reference = null;
  80                                 if (referenceMap != null){
  81                                         reference = referenceMap.get(refFk);
  82                                 }
  83
  84                                 if (taxonName == null ){
  85                                         logger.warn("TaxonName belonging to taxon (RIdentifier = " + taxonId + ") could not be found in store. Taxon will not be transported");
  86                                         continue;
  87                                 }else if (reference == null ){
  88                                         logger.warn("Reference belonging to taxon could not be found in store. Taxon will not be imported");
  89                                         continue;
  90                                 }else{
  91                                         TaxonBase taxonBase;
  92                                         Synonym synonym;
  93                                         Taxon taxon;
  94                                         try {
  95                                                 logger.debug(statusFk);
  96                                                 if (statusFk == T_STATUS_ACCEPTED){
  97                                                         taxon = Taxon.NewInstance(taxonName, reference);
  98                                                         taxonBase = taxon;
  99                                                 }else if (statusFk == T_STATUS_SYNONYM){
 100                                                         synonym = Synonym.NewInstance(taxonName, reference);
 101                                                         taxonBase = synonym;
 102                                                 }else{
 103                                                         logger.warn("TaxonStatus " + statusFk + " not yet implemented. Taxon (RIdentifier = " + taxonId + ") left out.");
 104                                                         continue;
 105                                                 }
 106
 107                                                 //TODO
 108 //                                              dbAttrName = "Detail";
 109 //                                              cdmAttrName = "Micro";
 110 //                                              ImportHelper.addStringValue(rs, taxonBase, dbAttrName, cdmAttrName);
 111
 112                                                 if (doubtful.equals("a")){
 113                                                         taxonBase.setDoubtful(false);
 114                                                 }else if(doubtful.equals("d")){
 115                                                         taxonBase.setDoubtful(true);
 116                                                 }else if(doubtful.equals("i")){
 117                                                         //TODO
 118                                                         logger.warn("Doubtful = i (inactivated) not yet implemented. Doubtful set to false");
 119                                                 }
 120
 121                                                 //nameId
 122                                                 ImportHelper.setOriginalSource(taxonBase, bmiConfig.getSourceReference(), taxonId);
 123
 124
 125                                                 //TODO
 126                                                 //
 127                                                 //Created
 128                                                 //Note
 129                                                 //ALL
 130
 131                                                 taxonMap.put(taxonId, taxonBase);
 132                                         } catch (Exception e) {
 133                                                 logger.warn("An exception occurred when creating taxon with id " + taxonId + ". Taxon could not be saved.");
 134                                         }
 135                                 }
 136                         }
 137                         //invokeRelations(source, cdmApp, deleteAll, taxonMap, referenceMap);
 138                         logger.info("saving taxa ...");
 139                         taxonService.saveTaxonAll(taxonMap.objects());
 140
 141                         logger.info("end makeTaxa ...");
 142
 143                         return true;
 144                 } catch (SQLException e) {
 145                         logger.error("SQLException:" +  e);
 146                         return false;
 147                 }
 148
 149         }
 150
 151
 152         public static boolean invokeRelations(BerlinModelImportConfigurator bmiConfig, CdmApplicationController cdmApp,
 153                         MapWrapper<TaxonBase> taxonMap, MapWrapper<ReferenceBase> referenceMap){
 154
 155                 Set<TaxonBase> taxonStore = new HashSet<TaxonBase>();
 156                 Source source = bmiConfig.getSource();
 157                 String dbAttrName;
 158                 String cdmAttrName;
 159
 160                 logger.info("start makeTaxonRelationships ...");
 161
 162                 ITaxonService taxonService = cdmApp.getTaxonService();
 163                 boolean delete = bmiConfig.isDeleteAll();
 164
 165                 try {
 166                         //get data from database
 167                         String strQuery =
 168                                         " SELECT RelPTaxon.*, FromTaxon.RIdentifier as taxon1Id, ToTaxon.RIdentifier as taxon2Id " +
 169                                         " FROM PTaxon as FromTaxon INNER JOIN " +
 170                         " RelPTaxon ON FromTaxon.PTNameFk = RelPTaxon.PTNameFk1 AND FromTaxon.PTRefFk = RelPTaxon.PTRefFk1 INNER JOIN " +
 171                         " PTaxon AS ToTaxon ON RelPTaxon.PTNameFk2 = ToTaxon.PTNameFk AND RelPTaxon.PTRefFk2 = ToTaxon.PTRefFk "+
 172                     " WHERE (1=1)";
 173                         ResultSet rs = source.getResultSet(strQuery) ;
 174
 175                         int i = 0;
 176                         //for each reference
 177                         while (rs.next()){
 178
 179                                 if ((i++ % modCount) == 0){ logger.info("RelPTaxa handled: " + (i-1));}
 180
 181                                 int relPTaxonId = rs.getInt("RelPTaxonId");
 182                                 int taxon1Id = rs.getInt("taxon1Id");
 183                                 int taxon2Id = rs.getInt("taxon2Id");
 184                                 int relRefFk = rs.getInt("relRefFk");
 185                                 int relQualifierFk = rs.getInt("relQualifierFk");
 186
 187                                 TaxonBase taxon1 = taxonMap.get(taxon1Id);
 188                                 TaxonBase taxon2 = taxonMap.get(taxon2Id);
 189
 190                                 //TODO
 191                                 ReferenceBase citation = null;
 192                                 String microcitation = null;
 193
 194                                 if (taxon2 != null && taxon1 != null){
 195                                         if (relQualifierFk == TAX_REL_IS_INCLUDED_IN){
 196                                                 ((Taxon)taxon2).addTaxonomicChild((Taxon)taxon1, citation, microcitation);
 197                                         }else if (relQualifierFk == TAX_REL_IS_SYNONYM_OF){
 198                                                 ((Taxon)taxon2).addSynonym((Synonym)taxon1, SynonymRelationshipType.SYNONYM_OF());
 199                                         }else if (relQualifierFk == TAX_REL_IS_HOMOTYPIC_SYNONYM_OF){
 200                                                 //TODO castexceptioin
 201                                                 ((Taxon)taxon2).addSynonym((Synonym)taxon1, SynonymRelationshipType.HOMOTYPIC_SYNONYM_OF());
 202                                         }else if (relQualifierFk == TAX_REL_IS_HETEROTYPIC_SYNONYM_OF){
 203                                                 if (Synonym.class.isAssignableFrom(taxon1.getClass())){
 204                                                         ((Taxon)taxon2).addSynonym((Synonym)taxon1, SynonymRelationshipType.HETEROTYPIC_SYNONYM_OF());
 205                                                 }else{
 206                                                         logger.warn("Taxon (RIdentifier = " + taxon1Id + ") can not be casted to Synonym");
 207                                                 }
 208                                         }else if (relQualifierFk == TAX_REL_IS_MISAPPLIED_NAME_OF){
 209                                                 ((Taxon)taxon2).addMisappliedName((Taxon)taxon1, citation, microcitation);
 210                                         }else {
 211                                                 //TODO
 212                                                 logger.warn("TaxonRelationShipType " + relQualifierFk + " not yet implemented");
 213                                         }
 214                                         taxonStore.add(taxon2);
 215
 216                                         //TODO
 217                                         //Reference
 218                                         //ID
 219                                         //etc.
 220                                 }else{
 221                                         //TODO
 222                                         logger.warn("Taxa for RelPTaxon " + relPTaxonId + " do not exist in store");
 223                                 }
 224                         }
 225                         logger.info("Taxa to save: " + taxonStore.size());
 226                         taxonService.saveTaxonAll(taxonStore);
 227
 228                         logger.info("end makeRelTaxa ...");
 229                         return true;
 230                 } catch (SQLException e) {
 231                         logger.error("SQLException:" +  e);
 232                         return false;
 233                 }
 234
 235         }
 236
 237
 238 }