cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/berlinModel/in/BerlinModelFactsImport.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.io.IOException;
  13 import java.net.URI;
  14 import java.net.URISyntaxException;
  15 import java.sql.ResultSet;
  16 import java.sql.SQLException;
  17 import java.util.HashMap;
  18 import java.util.HashSet;
  19 import java.util.Map;
  20 import java.util.Set;
  21 import java.util.UUID;
  22
  23 import org.apache.commons.lang.StringUtils;
  24 import org.apache.http.HttpException;
  25 import org.apache.log4j.Logger;
  26 import org.springframework.stereotype.Component;
  27
  28 import eu.etaxonomy.cdm.common.CdmUtils;
  29 import eu.etaxonomy.cdm.common.media.ImageInfo;
  30 import eu.etaxonomy.cdm.io.berlinModel.BerlinModelTransformer;
  31 import eu.etaxonomy.cdm.io.berlinModel.in.validation.BerlinModelFactsImportValidator;
  32 import eu.etaxonomy.cdm.io.common.IOValidator;
  33 import eu.etaxonomy.cdm.io.common.ResultSetPartitioner;
  34 import eu.etaxonomy.cdm.io.common.Source;
  35 import eu.etaxonomy.cdm.io.common.mapping.UndefinedTransformerMethodException;
  36 import eu.etaxonomy.cdm.model.common.Annotation;
  37 import eu.etaxonomy.cdm.model.common.CdmBase;
  38 import eu.etaxonomy.cdm.model.common.DescriptionElementSource;
  39 import eu.etaxonomy.cdm.model.common.Language;
  40 import eu.etaxonomy.cdm.model.common.Marker;
  41 import eu.etaxonomy.cdm.model.common.MarkerType;
  42 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  43 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  44 import eu.etaxonomy.cdm.model.description.Feature;
  45 import eu.etaxonomy.cdm.model.description.TaxonDescription;
  46 import eu.etaxonomy.cdm.model.description.TextData;
  47 import eu.etaxonomy.cdm.model.media.ImageFile;
  48 import eu.etaxonomy.cdm.model.media.Media;
  49 import eu.etaxonomy.cdm.model.media.MediaRepresentation;
  50 import eu.etaxonomy.cdm.model.reference.Reference;
  51 import eu.etaxonomy.cdm.model.taxon.Taxon;
  52 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  53 import eu.etaxonomy.cdm.strategy.exceptions.UnknownCdmTypeException;
  54
  55 /**
  56  * @author a.mueller
  57  * @created 20.03.2008
  58  * @version 1.0
  59  */
  60 @Component
  61 public class BerlinModelFactsImport  extends BerlinModelImportBase {
  62         private static final Logger logger = Logger.getLogger(BerlinModelFactsImport.class);
  63
  64         public static final String NAMESPACE = "Fact";
  65
  66         public static final String SEQUENCE_PREFIX = "ORDER: ";
  67
  68         private int modCount = 10000;
  69         private static final String pluralString = "facts";
  70         private static final String dbTableName = "Fact";
  71
  72         //FIXME don't use as class variable
  73         private Map<Integer, Feature> featureMap;
  74
  75         public BerlinModelFactsImport(){
  76                 super(dbTableName, pluralString);
  77         }
  78
  79
  80         private TermVocabulary<Feature> getFeatureVocabulary(){
  81                 try {
  82                         //TODO work around until service method works
  83                         TermVocabulary<Feature> featureVocabulary =  BerlinModelTransformer.factCategory2Feature(1).getVocabulary();
  84                         //TermVocabulary<Feature> vocabulary = getTermService().getVocabulary(vocabularyUuid);
  85                         return featureVocabulary;
  86                 } catch (UnknownCdmTypeException e) {
  87                         logger.error("Feature vocabulary not available. New vocabulary created");
  88                         return TermVocabulary.NewInstance("User Defined Feature Vocabulary", "User Defined Feature Vocabulary", null, null);
  89                 }
  90         }
  91
  92         private Map<Integer, Feature>  invokeFactCategories(BerlinModelImportState state){
  93
  94                 Map<Integer, Feature>  result = state.getConfig().getFeatureMap();
  95                 Source source = state.getConfig().getSource();
  96
  97                 try {
  98                         //get data from database
  99                         String strQuery =
 100                                         " SELECT FactCategory.* " +
 101                                         " FROM FactCategory "+
 102                     " WHERE (1=1)";
 103                         ResultSet rs = source.getResultSet(strQuery) ;
 104
 105
 106                         TermVocabulary<Feature> featureVocabulary = getFeatureVocabulary();
 107                         int i = 0;
 108                         //for each reference
 109                         while (rs.next()){
 110
 111                                 if ((i++ % modCount) == 0 && i!= 1 ){ logger.info("FactCategories handled: " + (i-1));}
 112
 113                                 int factCategoryId = rs.getInt("factCategoryId");
 114                                 String factCategory = rs.getString("factCategory");
 115
 116                                 Feature feature;
 117                                 try {
 118                                         feature = BerlinModelTransformer.factCategory2Feature(factCategoryId);
 119                                 } catch (UnknownCdmTypeException e) {
 120                                         UUID featureUuid = null;
 121                                         featureUuid = BerlinModelTransformer.getFeatureUuid(String.valueOf(factCategoryId+"-"+factCategory));
 122                                         if (featureUuid == null){
 123                                                 logger.warn("New Feature (FactCategoryId: " + factCategoryId + ")");
 124                                                 featureUuid = UUID.randomUUID();
 125                                         }
 126                                         feature = getFeature(state, featureUuid, factCategory, factCategory, null, featureVocabulary);
 127
 128                                         //TODO
 129 //                                      MaxFactNumber   int     Checked
 130 //                                      ExtensionTableName      varchar(100)    Checked
 131 //                                      Description     nvarchar(1000)  Checked
 132 //                                      locExtensionFormName    nvarchar(80)    Checked
 133 //                                      RankRestrictionFk       int     Checked
 134                                 }
 135
 136                                 result.put(factCategoryId, feature);
 137                         }
 138                         return result;
 139                 } catch (SQLException e) {
 140                         logger.error("SQLException:" +  e);
 141                         return null;
 142                 } catch (UndefinedTransformerMethodException e1) {
 143                         logger.error("UndefinedTransformerMethodException:" +  e1);
 144                         e1.printStackTrace();
 145                         return null;
 146                 }
 147
 148         }
 149
 150         /* (non-Javadoc)
 151          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#doInvoke(eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState)
 152          */
 153         @Override
 154         protected void doInvoke(BerlinModelImportState state) {
 155                 featureMap = invokeFactCategories(state);
 156                 super.doInvoke(state);
 157                 return;
 158         }
 159
 160
 161
 162         /* (non-Javadoc)
 163          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getIdQuery(eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState)
 164          */
 165         @Override
 166         protected String getIdQuery(BerlinModelImportState state) {
 167                 String result = super.getIdQuery(state);
 168                 if (StringUtils.isNotBlank(state.getConfig().getFactFilter())){
 169                         result += " WHERE " + state.getConfig().getFactFilter();
 170                 }else{
 171                         result = super.getIdQuery(state);
 172                 }
 173                 result += getOrderBy(state.getConfig());
 174                 return result;
 175         }
 176
 177
 178
 179         /* (non-Javadoc)
 180          * @see eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportBase#getRecordQuery(eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportConfigurator)
 181          */
 182         @Override
 183         protected String getRecordQuery(BerlinModelImportConfigurator config) {
 184                         String strQuery =
 185                                         " SELECT Fact.*, PTaxon.RIdentifier as taxonId, RefDetail.Details " +
 186                                         " FROM Fact " +
 187                         " INNER JOIN PTaxon ON Fact.PTNameFk = PTaxon.PTNameFk AND Fact.PTRefFk = PTaxon.PTRefFk " +
 188                         " LEFT OUTER JOIN RefDetail ON Fact.FactRefDetailFk = RefDetail.RefDetailId AND Fact.FactRefFk = RefDetail.RefFk " +
 189                 " WHERE (FactId IN (" + ID_LIST_TOKEN + "))";
 190                             strQuery += getOrderBy(config);
 191
 192                 return strQuery;
 193         }
 194
 195
 196         private String getOrderBy(BerlinModelImportConfigurator config) {
 197                 String result;
 198                 try{
 199                         if (config.getSource().checkColumnExists("Fact", "Sequence")){
 200                                 result = " ORDER By Fact.Sequence, Fact.FactId";
 201                         }else{
 202                                 result = " ORDER By Fact.FactId";
 203                         }
 204                 } catch (NoSuchMethodException e) {
 205                         logger.info("checkColumnExists not supported");
 206                         result = " ORDER By Fact.FactId";
 207                 }
 208                 return result;
 209         }
 210
 211
 212         /* (non-Javadoc)
 213          * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#doPartition(eu.etaxonomy.cdm.io.berlinModel.in.ResultSetPartitioner, eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState)
 214          */
 215         public boolean doPartition(ResultSetPartitioner partitioner, BerlinModelImportState state) {
 216                 boolean success = true ;
 217                 BerlinModelImportConfigurator config = state.getConfig();
 218                 Set<TaxonBase> taxaToSave = new HashSet<TaxonBase>();
 219                 Map<String, TaxonBase> taxonMap = (Map<String, TaxonBase>) partitioner.getObjectMap(BerlinModelTaxonImport.NAMESPACE);
 220                 Map<String, Reference> biblioRefMap = (Map<String, Reference>) partitioner.getObjectMap(BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE);
 221                 Map<String, Reference> nomRefMap = (Map<String, Reference>) partitioner.getObjectMap(BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE);
 222
 223                 ResultSet rs = partitioner.getResultSet();
 224
 225                 Reference<?> sourceRef = state.getTransactionalSourceReference();
 226
 227                 try{
 228                         int i = 0;
 229                         //for each fact
 230                         while (rs.next()){
 231                                 try{
 232                                         if ((i++ % modCount) == 0){ logger.info("Facts handled: " + (i-1));}
 233
 234                                         int factId = rs.getInt("factId");
 235                                         Object taxonIdObj = rs.getObject("taxonId");
 236                                         long taxonId = rs.getLong("taxonId");
 237                                         Object factRefFkObj = rs.getObject("factRefFk");
 238                                         Object categoryFkObj = rs.getObject("factCategoryFk");
 239                                         Integer categoryFk = rs.getInt("factCategoryFk");
 240                                         String details = rs.getString("Details");
 241                                         String fact = CdmUtils.Nz(rs.getString("Fact"));
 242                                         String notes = CdmUtils.Nz(rs.getString("notes"));
 243                                         Boolean doubtfulFlag = rs.getBoolean("DoubtfulFlag");
 244
 245                                         TaxonBase<?> taxonBase = getTaxon(taxonMap, taxonIdObj, taxonId);
 246                                         Feature feature = getFeature(featureMap, categoryFkObj, categoryFk) ;
 247
 248                                         if (taxonBase == null){
 249                                                 logger.warn("Taxon for Fact " + factId + " does not exist in store");
 250                                                 success = false;
 251                                         }else{
 252                                                 TaxonDescription taxonDescription;
 253                                                 if ( (taxonDescription = getMyTaxonDescripion(taxonBase, state, categoryFk, taxonIdObj, taxonId, factId, fact, sourceRef)) == null){
 254                                                         success = false;
 255                                                         continue;
 256                                                 }
 257
 258                                                 //textData
 259                                                 TextData textData = null;
 260                                                 boolean newTextData = true;
 261
 262                                                 // For Cichorieae DB: If fact category is 31 (Systematics) and there is already a Systematics TextData
 263                                                 // description element append the fact text to the existing TextData
 264                                                 if(categoryFk == 31) {
 265                                                         Set<DescriptionElementBase> descriptionElements = taxonDescription.getElements();
 266                                                         for (DescriptionElementBase descriptionElement : descriptionElements) {
 267                                                                 String featureString = descriptionElement.getFeature().getRepresentation(Language.DEFAULT()).getLabel();
 268                                                                 if (descriptionElement instanceof TextData && featureString.equals("Systematics")) { // TODO: test
 269                                                                         textData = (TextData)descriptionElement;
 270                                                                         String factTextStr = textData.getText(Language.DEFAULT());
 271                                                                         // FIXME: Removing newlines doesn't work
 272                                                                         if (factTextStr.contains("\\r\\n")) {
 273                                                                                 factTextStr = factTextStr.replaceAll("\\r\\n","");
 274                                                                         }
 275                                                                         StringBuilder factText = new StringBuilder(factTextStr);
 276                                                                         factText.append(fact);
 277                                                                         fact = factText.toString();
 278                                                                         newTextData = false;
 279                                                                         break;
 280                                                                 }
 281                                                         }
 282                                                 }
 283
 284                                                 if(newTextData == true) {
 285                                                         textData = TextData.NewInstance();
 286                                                 }
 287
 288                                                 //for diptera database
 289                                                 if (categoryFk == 99 && notes.contains("<OriginalName>")){
 290 //                                                      notes = notes.replaceAll("<OriginalName>", "");
 291 //                                                      notes = notes.replaceAll("</OriginalName>", "");
 292                                                         fact = notes + ": " +  fact ;
 293                                                 }
 294                                                 //for E+M maps
 295                                                 if (categoryFk == 14 && state.getConfig().isRemoveHttpMapsAnchor() && fact.contains("<a href")){
 296                                                         //example <a href="http://euromed.luomus.fi/euromed_map.php?taxon=280629&size=medium">distribution</a>
 297                                                         fact = fact.replace("<a href=\"", "").replace("\">distribution</a>", "");
 298                                                 }
 299
 300                                                 //TODO textData.putText(fact, bmiConfig.getFactLanguage());  //doesn't work because  bmiConfig.getFactLanguage() is not not a persistent Language Object
 301                                                 //throws  in thread "main" org.springframework.dao.InvalidDataAccessApiUsageException: object references an unsaved transient instance - save the transient instance before flushing: eu.etaxonomy.cdm.model.common.Language; nested exception is org.hibernate.TransientObjectException: object references an unsaved transient instance - save the transient instance before flushing: eu.etaxonomy.cdm.model.common.Language
 302                                                 if (! taxonDescription.isImageGallery()){
 303                                                         textData.putText(Language.DEFAULT(), fact);
 304                                                         textData.setFeature(feature);
 305                                                 }
 306
 307                                                 //reference
 308                                                 Reference<?> citation = null;
 309                                                 String factRefFk = String.valueOf(factRefFkObj);
 310                                                 if (factRefFkObj != null){
 311                                                         citation = getReferenceOnlyFromMaps(biblioRefMap, nomRefMap, factRefFk);
 312                                                         }
 313                                                 if (citation == null && (factRefFkObj != null)){
 314                                                                 logger.warn("Citation not found in referenceMap: " + factRefFk);
 315                                                         success = false;
 316                                                         }
 317                                                 if (citation != null || StringUtils.isNotBlank(details)){
 318                                                         DescriptionElementSource originalSource = DescriptionElementSource.NewPrimarySourceInstance(citation, details);
 319                                                         textData.addSource(originalSource);
 320                                                 }
 321                                                 taxonDescription.addElement(textData);
 322                                                 //doubtfulFlag
 323                                                 if (doubtfulFlag){
 324                                                         textData.addMarker(Marker.NewInstance(MarkerType.IS_DOUBTFUL(), true));
 325                                                 }
 326                                                 //publisheFlag
 327                                                 String strPublishFlag = "publishFlag";
 328                                                 boolean publishFlagExists = state.getConfig().getSource().checkColumnExists(dbTableName, strPublishFlag);
 329                                                 if (publishFlagExists){
 330                                                         Boolean publishFlag = rs.getBoolean(strPublishFlag);
 331                                                         textData.addMarker(Marker.NewInstance(MarkerType.PUBLISH(), publishFlag));
 332                                                 }
 333
 334                                                 //Sequence
 335                                                 Integer sequence = rs.getInt("Sequence");
 336                                                 if (sequence != null && sequence != 999){
 337                                                         String strSequence = String.valueOf(sequence);
 338                                                         strSequence = SEQUENCE_PREFIX + strSequence;
 339                                                         //TODO make it an Extension when possible
 340                                                         //Extension datesExtension = Extension.NewInstance(textData, strSequence, ExtensionType.ORDER());
 341                                                         Annotation annotation = Annotation.NewInstance(strSequence, Language.DEFAULT());
 342                                                         textData.addAnnotation(annotation);
 343                                                 }
 344
 345                                                 //                                              if (categoryFkObj == FACT_DESCRIPTION){
 346         //                                              //;
 347         //                                      }else if (categoryFkObj == FACT_OBSERVATION){
 348         //                                              //;
 349         //                                      }else if (categoryFkObj == FACT_DISTRIBUTION_EM){
 350         //                                              //
 351         //                                      }else {
 352         //                                              //TODO
 353         //                                              //logger.warn("FactCategory " + categoryFk + " not yet implemented");
 354         //                                      }
 355
 356                                                 //notes
 357                                                 doCreatedUpdatedNotes(state, textData, rs);
 358
 359                                                 //TODO
 360                                                 //Designation References -> unclear how to map to CDM
 361                                                 //factId -> OriginalSource for descriptionElements not yet implemented
 362
 363                                                 //sequence -> textData is not an identifiable entity therefore extensions are not possible
 364                                                 //fact category better
 365
 366                                                 taxaToSave.add(taxonBase);
 367                                         }
 368                                 } catch (Exception re){
 369                                         logger.error("An exception occurred during the facts import");
 370                                         re.printStackTrace();
 371                                         success = false;
 372                                 }
 373                                 //put
 374                         }
 375                         logger.info("Facts handled: " + (i-1));
 376                         logger.info("Taxa to save: " + taxaToSave.size());
 377                         getTaxonService().save(taxaToSave);
 378                 }catch(SQLException e){
 379                         throw new RuntimeException(e);
 380                 }
 381                 return success;
 382         }
 383
 384         private TaxonDescription getMyTaxonDescripion(TaxonBase taxonBase, BerlinModelImportState state, Integer categoryFk, Object taxonIdObj, long taxonId, int factId, String fact, Reference<?> sourceRef) {
 385                 Taxon taxon = null;
 386                 if ( taxonBase instanceof Taxon ) {
 387                         taxon = (Taxon) taxonBase;
 388                 }else{
 389                         logger.warn("TaxonBase " + (taxonIdObj==null?"(null)":taxonIdObj) + " for Fact " + factId + " was not of type Taxon but: " + taxonBase.getClass().getSimpleName());
 390                         return null;
 391                 }
 392
 393                 TaxonDescription taxonDescription = null;
 394                 Set<TaxonDescription> descriptionSet= taxon.getDescriptions();
 395
 396                 boolean isImage = false;
 397                 Media media = null;
 398                 //for diptera images
 399                 if (categoryFk == 51){  //TODO check also FactCategory string
 400                         isImage = true;
 401                         media = Media.NewInstance();
 402                         taxonDescription = makeImage(state, fact, media, descriptionSet, taxon);
 403
 404
 405
 406                         if (taxonDescription == null){
 407                                 return null;
 408                         }
 409
 410                         TextData textData = null;
 411                         for (DescriptionElementBase el:  taxonDescription.getElements()){
 412                                 if (el.isInstanceOf(TextData.class)){
 413                                         textData = CdmBase.deproxy(el, TextData.class);
 414                                 }
 415                         }
 416                         if (textData == null){
 417                                 textData = TextData.NewInstance(Feature.IMAGE());
 418                                 taxonDescription.addElement(textData);
 419                         }
 420                         textData.addMedia(media);
 421                 }
 422                 //all others (no image) -> getDescription
 423                 else{
 424                         for (TaxonDescription desc: descriptionSet){
 425                                 if (! desc.isImageGallery()){
 426                                         taxonDescription = desc;
 427                                 }
 428                         }
 429                         if (taxonDescription == null){
 430                                 taxonDescription = TaxonDescription.NewInstance();
 431                                 taxonDescription.setTitleCache(sourceRef == null ? null : sourceRef.getTitleCache(), true);
 432                                 taxon.addDescription(taxonDescription);
 433                         }
 434                 }
 435                 return taxonDescription;
 436         }
 437
 438
 439         /* (non-Javadoc)
 440          * @see eu.etaxonomy.cdm.io.berlinModel.in.IPartitionedIO#getRelatedObjectsForPartition(java.sql.ResultSet)
 441          */
 442         public Map<Object, Map<String, ? extends CdmBase>> getRelatedObjectsForPartition(ResultSet rs) {
 443                 String nameSpace;
 444                 Class cdmClass;
 445                 Set<String> idSet;
 446                 Map<Object, Map<String, ? extends CdmBase>> result = new HashMap<Object, Map<String, ? extends CdmBase>>();
 447
 448                 try{
 449                         Set<String> taxonIdSet = new HashSet<String>();
 450                         Set<String> referenceIdSet = new HashSet<String>();
 451                         Set<String> refDetailIdSet = new HashSet<String>();
 452                         while (rs.next()){
 453                                 handleForeignKey(rs, taxonIdSet, "taxonId");
 454                                 handleForeignKey(rs, referenceIdSet, "FactRefFk");
 455                                 handleForeignKey(rs, referenceIdSet, "PTDesignationRefFk");
 456                                 handleForeignKey(rs, refDetailIdSet, "FactRefDetailFk");
 457                                 handleForeignKey(rs, refDetailIdSet, "PTDesignationRefDetailFk");
 458                 }
 459
 460                         //taxon map
 461                         nameSpace = BerlinModelTaxonImport.NAMESPACE;
 462                         cdmClass = TaxonBase.class;
 463                         idSet = taxonIdSet;
 464                         Map<String, TaxonBase> taxonMap = (Map<String, TaxonBase>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 465                         result.put(nameSpace, taxonMap);
 466
 467
 468                         //nom reference map
 469                         nameSpace = BerlinModelReferenceImport.NOM_REFERENCE_NAMESPACE;
 470                         cdmClass = Reference.class;
 471                         idSet = referenceIdSet;
 472                         Map<String, Reference> nomReferenceMap = (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 473                         result.put(nameSpace, nomReferenceMap);
 474
 475                         //biblio reference map
 476                         nameSpace = BerlinModelReferenceImport.BIBLIO_REFERENCE_NAMESPACE;
 477                         cdmClass = Reference.class;
 478                         idSet = referenceIdSet;
 479                         Map<String, Reference> biblioReferenceMap = (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 480                         result.put(nameSpace, biblioReferenceMap);
 481
 482                         //nom refDetail map
 483                         nameSpace = BerlinModelRefDetailImport.NOM_REFDETAIL_NAMESPACE;
 484                         cdmClass = Reference.class;
 485                         idSet = refDetailIdSet;
 486                         Map<String, Reference> nomRefDetailMap= (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 487                         result.put(nameSpace, nomRefDetailMap);
 488
 489                         //biblio refDetail map
 490                         nameSpace = BerlinModelRefDetailImport.BIBLIO_REFDETAIL_NAMESPACE;
 491                         cdmClass = Reference.class;
 492                         idSet = refDetailIdSet;
 493                         Map<String, Reference> biblioRefDetailMap= (Map<String, Reference>)getCommonService().getSourcedObjectsByIdInSource(cdmClass, idSet, nameSpace);
 494                         result.put(nameSpace, biblioRefDetailMap);
 495
 496                 } catch (SQLException e) {
 497                         throw new RuntimeException(e);
 498         }
 499                 return result;
 500         }
 501
 502
 503         /**
 504          * @param state
 505          * @param media
 506          * @param media
 507          * @param descriptionSet
 508          *
 509          */
 510         private TaxonDescription makeImage(BerlinModelImportState state, String fact, Media media, Set<TaxonDescription> descriptionSet, Taxon taxon) {
 511                 TaxonDescription taxonDescription = null;
 512                 Reference sourceRef = state.getTransactionalSourceReference();
 513                 Integer size = null;
 514                 ImageInfo imageInfo = null;
 515                 URI uri;
 516                 try {
 517                         uri = new URI(fact.trim());
 518                 } catch (URISyntaxException e) {
 519                         logger.warn("URISyntaxException. Image could not be imported: " + fact);
 520                         return null;
 521                 }
 522                 try {
 523                         imageInfo = ImageInfo.NewInstance(uri, 0);
 524                 } catch (IOException e) {
 525                         logger.error("IOError reading image metadata." , e);
 526                 } catch (HttpException e) {
 527                         logger.error("HttpException reading image metadata." , e);
 528                 }
 529                 MediaRepresentation mediaRepresentation = MediaRepresentation.NewInstance(imageInfo.getMimeType(), null);
 530                 media.addRepresentation(mediaRepresentation);
 531                 ImageFile image = ImageFile.NewInstance(uri, size, imageInfo);
 532                 mediaRepresentation.addRepresentationPart(image);
 533
 534                 taxonDescription = taxon.getOrCreateImageGallery(sourceRef == null ? null :sourceRef.getTitleCache());
 535
 536                 return taxonDescription;
 537         }
 538
 539         private TaxonBase getTaxon(Map<String, TaxonBase> taxonMap, Object taxonIdObj, Long taxonId){
 540                 if (taxonIdObj != null){
 541                         return taxonMap.get(String.valueOf(taxonId));
 542                 }else{
 543                         return null;
 544                 }
 545
 546         }
 547
 548         private Feature getFeature(Map<Integer, Feature>  featureMap, Object categoryFkObj, Integer categoryFk){
 549                 if (categoryFkObj != null){
 550                         return featureMap.get(categoryFk);
 551                 }else{
 552                         return null;
 553                 }
 554
 555         }
 556
 557
 558         /* (non-Javadoc)
 559          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#doCheck(eu.etaxonomy.cdm.io.common.IoStateBase)
 560          */
 561         @Override
 562         protected boolean doCheck(BerlinModelImportState state){
 563                 IOValidator<BerlinModelImportState> validator = new BerlinModelFactsImportValidator();
 564                 return validator.validate(state);
 565         }
 566
 567         /* (non-Javadoc)
 568          * @see eu.etaxonomy.cdm.io.common.CdmIoBase#isIgnore(eu.etaxonomy.cdm.io.common.IImportConfigurator)
 569          */
 570         protected boolean isIgnore(BerlinModelImportState state){
 571                 return ! state.getConfig().isDoFacts();
 572         }
 573
 574
 575
 576 }