app-import/src/main/java/eu/etaxonomy/cdm/io/wp6/CommonNameExcelImport.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.wp6;
  11
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.Set;
  16 import java.util.UUID;
  17
  18 import org.apache.commons.lang.StringUtils;
  19 import org.apache.log4j.Logger;
  20 import org.hibernate.criterion.Criterion;
  21 import org.springframework.stereotype.Component;
  22
  23 import eu.etaxonomy.cdm.common.CdmUtils;
  24 import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;
  25 import eu.etaxonomy.cdm.io.excel.common.ExcelImporterBase;
  26 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  27 import eu.etaxonomy.cdm.model.common.Language;
  28 import eu.etaxonomy.cdm.model.common.OriginalSourceType;
  29 import eu.etaxonomy.cdm.model.common.TermType;
  30 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  31 import eu.etaxonomy.cdm.model.description.CommonTaxonName;
  32 import eu.etaxonomy.cdm.model.description.DescriptionElementSource;
  33 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  34 import eu.etaxonomy.cdm.model.location.NamedArea;
  35 import eu.etaxonomy.cdm.model.location.Country;
  36 import eu.etaxonomy.cdm.model.reference.Reference;
  37 import eu.etaxonomy.cdm.model.taxon.Taxon;
  38 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  39
  40 /**
  41  * @author a.babadshanjan
  42  * @created 08.01.2009
  43  * @version 1.0
  44  */
  45
  46 @Component
  47 public class CommonNameExcelImport extends ExcelImporterBase<CichorieaeCommonNameImportState> {
  48         private static final Logger logger = Logger.getLogger(CommonNameExcelImport.class);
  49
  50         protected static final String SPECIES_COLUMN = "Art";
  51         protected static final String COMMON_NAME_COLUMN = "common name";
  52         protected static final String REFERENCE_COLUMN = "Literaturnummer";
  53         protected static final String DISTIRBUTION_COLUMN = "Verbreitung";
  54         protected static final String AREA_COLUMN = "Vorschlag Bezeichnung L�nder/Regionen";
  55
  56         private Map<String, NamedArea> areaStore = new HashMap<String, NamedArea>();
  57         private Map<String, Language> languageStore = new HashMap<String, Language>();
  58
  59
  60         @Override
  61         protected boolean isIgnore(CichorieaeCommonNameImportState state) {
  62                 return false;
  63         }
  64
  65
  66         /* (non-Javadoc)
  67          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IoStateBase)
  68          */
  69         @Override
  70         protected boolean doCheck(CichorieaeCommonNameImportState state) {
  71                 logger.warn("DoCheck not yet implemented for CommonNameExcelImport");
  72                 return true;
  73         }
  74
  75
  76         @Override
  77     protected void analyzeRecord(HashMap<String, String> record, CichorieaeCommonNameImportState state) {
  78                 Set<String> keys = record.keySet();
  79
  80         CommonNameRow row = new CommonNameRow();
  81         state.setCommonNameRow(row);
  82
  83         for (String originalKey: keys) {
  84                 String indexedKey = CdmUtils.removeDuplicateWhitespace(originalKey.trim()).toString();
  85                 String[] split = indexedKey.split("_");
  86                 String key = split[0];
  87                 if (split.length > 1){
  88                         String indexString = split[1];
  89                         try {
  90                                 Integer.valueOf(indexString);
  91                                 } catch (NumberFormatException e) {
  92                                         String message = "Index must be integer";
  93                                         logger.error(message);
  94                                         continue;
  95                                 }
  96                 }
  97
  98                 String value = (String) record.get(indexedKey);
  99                 if (! StringUtils.isBlank(value)) {
 100                         if (logger.isDebugEnabled()) { logger.debug(key + ": " + value); }
 101                         value = CdmUtils.removeDuplicateWhitespace(value.trim()).toString();
 102                 }else{
 103                         continue;
 104                 }
 105
 106
 107                 if (key.equalsIgnoreCase(SPECIES_COLUMN)) {
 108                         row.parseSpecies(value);
 109
 110                         } else if(key.equalsIgnoreCase(COMMON_NAME_COLUMN)) {
 111                                 row.setCommonNames(value);
 112
 113                         } else if(key.equalsIgnoreCase(REFERENCE_COLUMN)) {
 114                                 row.setReference(value);
 115                         } else if(key.equalsIgnoreCase(DISTIRBUTION_COLUMN)) {
 116                                 //do nothing
 117
 118                         } else if(key.equalsIgnoreCase(AREA_COLUMN)) {
 119                                 row.setArea(value);
 120                         } else {
 121                                 state.setUnsuccessfull();
 122                                 logger.error("Unexpected column header " + key);
 123                         }
 124         }
 125         return;
 126     }
 127
 128
 129         /**
 130          *  Stores taxa records in DB
 131          */
 132         @Override
 133     protected void firstPass(CichorieaeCommonNameImportState state) {
 134
 135                 CommonNameRow taxonLight = state.getCommonNameRow();
 136                 //species name
 137                 String speciesStr = taxonLight.getSpecies();
 138                 TaxonDescription taxonDesc = getTaxon(state, speciesStr);
 139                 Reference<?> ref = getReference(state, taxonLight);
 140
 141                 NamedArea area = getArea(state, taxonLight.getArea());
 142
 143                 makeCommonNames(state, taxonLight.getCommonNames(), taxonDesc, ref, area, taxonLight.getNameUsedInSource());
 144
 145 //              OLD
 146 //              TaxonNameBase nameUsedInSource = getNameUsedInSource(state, taxonLight.getNameUsedInSource());
 147
 148                 getTaxonService().save(taxonDesc.getTaxon());
 149                 return;
 150     }
 151
 152
 153
 154         private Map<String, Reference> referenceStore = new HashMap<String, Reference>();
 155         private Reference getReference(CichorieaeCommonNameImportState state, CommonNameRow taxonLight) {
 156                 String reference = taxonLight.getReference();
 157                 Reference result = referenceStore.get(reference);
 158                 if (result == null){
 159                         result = (Reference)getCommonService().getSourcedObjectByIdInSource(Reference.class, reference, "import to Berlin Model");
 160                         if (result == null){
 161                                 logger.warn("Reference not found: " + reference + " for taxon " + taxonLight.getSpecies());
 162 //                              result = ReferenceFactory.newGeneric();
 163 //                              result.setTitleCache(reference);
 164                         }else{
 165                                 referenceStore.put(reference, result);
 166                         }
 167                 }
 168                 return result;
 169         }
 170
 171
 172
 173         private NamedArea getArea(CichorieaeCommonNameImportState state, String area) {
 174                 NamedArea result;
 175                 List<OrderHint> orderHints = null;
 176                 List<Criterion> criteria = null;
 177                 result = areaStore.get(area);
 178
 179                 if (result == null){
 180                         try {
 181                                 result = state.getTransformer().getNamedAreaByKey(area);
 182                         } catch (UndefinedTransformerMethodException e) {
 183                                 e.printStackTrace();
 184                         }
 185                         if (result == null){
 186                                 List<DefinedTermBase> candidates = getTermService().findByTitle(Country.class, area, null, criteria, null, null, orderHints, null).getRecords();
 187                                 if (candidates.size() == 0){
 188                                         candidates = getTermService().findByTitle(NamedArea.class, area, null, criteria, null, null, orderHints, null).getRecords();
 189                                 }
 190                                 if (candidates.size()>0){
 191                                         //TODO
 192                                         result = (NamedArea)candidates.get(0);
 193                                 }else{
 194                                         UUID uuidArea;
 195                                         try {
 196                                                 uuidArea = state.getTransformer().getNamedAreaUuid(area);
 197                                                 if (uuidArea == null){
 198                                                         logger.warn("Area not defined: " + area)  ;
 199                                                 }
 200                                                 result = getNamedArea(state, uuidArea, area, area, null, null, null);
 201                                         } catch (UndefinedTransformerMethodException e) {
 202                                                 e.printStackTrace();
 203                                         }
 204                                         if (result == null){
 205                                                 logger.warn("Area not defined: " + area)  ;
 206                                         }
 207                                 }
 208                         }
 209                         areaStore.put(area, result);
 210                 }
 211                 return result;
 212         }
 213
 214
 215         Map<String, TaxonDescription> taxonStore = new HashMap<String, TaxonDescription>();
 216
 217         private TaxonDescription getTaxon(CichorieaeCommonNameImportState state, String taxonNameStr) {
 218                 TaxonDescription desc;
 219                 Taxon taxon;
 220
 221                 if (taxonStore.get(taxonNameStr) != null){
 222                         desc = taxonStore.get(taxonNameStr);
 223                 }else{
 224                         taxon = getTaxonService().findBestMatchingTaxon(taxonNameStr);
 225 //                      TaxonNameBase name = BotanicalName.NewInstance(Rank.SPECIES());
 226 //                      name.setTitleCache(taxonNameStr, true);
 227 //
 228 //                      result = Taxon.NewInstance(name, null);
 229                         if (taxon == null){
 230                                 logger.warn("Taxon not found: " +  taxonNameStr);
 231                                 desc = null;
 232                         }else{
 233                                 desc = getNewDescription(state, taxon);
 234                                 taxonStore.put(taxonNameStr, desc);
 235                         }
 236                 }
 237                 return desc;
 238         }
 239
 240         private TaxonDescription getNewDescription(CichorieaeCommonNameImportState state, Taxon taxon) {
 241                 Reference<?> excelRef = state.getConfig().getSourceReference();
 242                 TaxonDescription desc = TaxonDescription.NewInstance(taxon, false);
 243                 desc.setTitleCache("Common Names Excel import", true);
 244                 desc.addSource(OriginalSourceType.Import, null, null, excelRef, null);
 245                 return desc;
 246         }
 247
 248
 249         private void makeCommonNames(CichorieaeCommonNameImportState state, Map<String, List<String>> commonNamesMap, TaxonDescription description, Reference ref, NamedArea area, String nameUsedInSource) {
 250                 //Common Names
 251 //              TaxonDescription td = this.getTaxonDescription(mainTaxon, false, true);
 252                 for (String languageKey : commonNamesMap.keySet()){
 253                         Language language = getLanguage(state, languageKey);
 254                         List<String> commonNamesList = commonNamesMap.get(languageKey);
 255                         for (String strCommonName : commonNamesList){
 256                                 CommonTaxonName commonName = CommonTaxonName.NewInstance(strCommonName, language, area);
 257                                 if (ref != null || StringUtils.isNotBlank(nameUsedInSource)){
 258                                         DescriptionElementSource source = DescriptionElementSource.NewPrimarySourceInstance(ref, null);
 259                                         source.setOriginalNameString(nameUsedInSource);
 260                                         commonName.addSource(source);
 261                                 }else{
 262                                         logger.debug("No reference defined");
 263                                 }
 264                                 description.addElement(commonName);
 265                         }
 266                 }
 267         }
 268
 269         private Language getLanguage(CichorieaeCommonNameImportState state, String languageKey) {
 270                 if (languageKey.equals("*")){
 271                         return null;
 272                 }
 273                 Language result;
 274                 languageKey = languageKey.replace(", no ISO-Code", "");
 275                 result = languageStore.get(languageKey);
 276                 if (result == null){
 277                         try{
 278                                 if (languageKey.length()<4){
 279                                         try {
 280                                                 result = getTermService().getLanguageByIso(languageKey);
 281                                         } catch (Exception e) {
 282                                                 // TODO Auto-generated catch block
 283                                                 e.printStackTrace();
 284                                         }
 285                                 }else{
 286                                         UUID uuid = state.getTransformer().getLanguageUuid(languageKey);
 287                                         result = (Language)getTermService().find(uuid);
 288                                 }
 289                                 if (result == null){
 290                                         result = state.getTransformer().getLanguageByKey(languageKey);
 291                                         if (result == null){
 292                                                 UUID uuidLanguage;
 293                                                 uuidLanguage = state.getTransformer().getLanguageUuid(languageKey);
 294                                                 if (uuidLanguage == null){
 295                                                         logger.warn("Language not defined: " + languageKey)  ;
 296                                                 }
 297                                                 result = getLanguage(state, uuidLanguage, languageKey, languageKey, null);
 298                                                 if (result == null){
 299                                                         logger.warn("Language not defined: " + languageKey)  ;
 300                                                 }
 301                                         }else if (result.getId() == 0){
 302 //                                              UUID uuidLanguageVoc = UUID.fromString("45ac7043-7f5e-4f37-92f2-3874aaaef2de");
 303                                                 UUID uuidLanguageVoc = UUID.fromString("434cea89-9052-4567-b2db-ff77f42e9084");
 304                                                 TermVocabulary<Language> voc = getVocabulary(TermType.Language, uuidLanguageVoc, "User Defined Languages", "User Defined Languages", null, null, false, result);
 305 //                                              TermVocabulary<Language> voc = getVocabularyService().find(uuidLanguageVoc);
 306                                                 voc.addTerm(result);
 307                                                 getTermService().saveOrUpdate(result);
 308                                                 state.putLanguage(result);
 309                                         }
 310                                 }
 311                                 languageStore.put(languageKey, result);
 312                         } catch (UndefinedTransformerMethodException e) {
 313                                 e.printStackTrace();
 314                         }
 315
 316                 }
 317                 return result;
 318         }
 319
 320
 321         /**
 322          *  Stores parent-child, synonym and common name relationships
 323          */
 324         @Override
 325     protected void secondPass(CichorieaeCommonNameImportState state) {
 326                 //no second pass
 327                 return;
 328         }
 329
 330
 331
 332 //      private TaxonNameBase getNameUsedInSource(CichorieaeCommonNameImportState state, String nameUsedInSource) {
 333 //              if (StringUtils.isBlank(nameUsedInSource)){
 334 //                      return null;
 335 //              }else{
 336 //                      Pager<TaxonNameBase> list = getNameService().findByName(BotanicalName.class, nameUsedInSource, null, null, null, null, null, null);
 337 //                      if (list.getCount() > 0){
 338 //                              return list.getRecords().get(0);
 339 //                      }else{
 340 //                              return null;
 341 //                      }
 342 //              }
 343 //
 344 //      }
 345
 346
 347
 348 }