cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/common/CdmApplicationAwareDefaultImport.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.common;
  11
  12 import java.util.HashMap;
  13 import java.util.Map;
  14
  15 import org.apache.log4j.Logger;
  16 import org.springframework.beans.BeansException;
  17 import org.springframework.context.ApplicationContext;
  18 import org.springframework.context.ApplicationContextAware;
  19 import org.springframework.stereotype.Component;
  20
  21 import eu.etaxonomy.cdm.api.service.IService;
  22 import eu.etaxonomy.cdm.io.berlinModel.in.BerlinModelImportState;
  23 import eu.etaxonomy.cdm.model.agent.Person;
  24 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  25 import eu.etaxonomy.cdm.model.common.CdmBase;
  26 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  27 import eu.etaxonomy.cdm.model.occurrence.Specimen;
  28 import eu.etaxonomy.cdm.model.reference.ReferenceBase;
  29 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  30
  31 /**
  32  * @author a.mueller
  33  * @created 20.06.2008
  34  * @version 1.0
  35  */
  36
  37 @Component("defaultImport")
  38 public class CdmApplicationAwareDefaultImport<T extends IImportConfigurator> implements ICdmImporter<T>, ApplicationContextAware {
  39         private static final Logger logger = Logger.getLogger(CdmApplicationAwareDefaultImport.class);
  40
  41         protected ApplicationContext applicationContext;
  42
  43         /* (non-Javadoc)
  44          * @see org.springframework.context.ApplicationContextAware#setApplicationContext(org.springframework.context.ApplicationContext)
  45          */
  46         public void setApplicationContext(ApplicationContext applicationContext)
  47                         throws BeansException {
  48                 this.applicationContext = applicationContext;
  49         }
  50
  51
  52         //Constants
  53         final boolean OBLIGATORY = true;
  54         final boolean FACULTATIVE = false;
  55         final int modCount = 1000;
  56
  57         IService<CdmBase> service = null;
  58
  59         //different type of stores that are used by the known imports
  60         Map<String, MapWrapper<? extends CdmBase>> stores = new HashMap<String, MapWrapper<? extends CdmBase>>();
  61
  62         public CdmApplicationAwareDefaultImport(){
  63
  64
  65                 stores.put(ICdmIO.PERSON_STORE, new MapWrapper<Person>(service));
  66                 stores.put(ICdmIO.TEAM_STORE, new MapWrapper<TeamOrPersonBase<?>>(service));
  67                 stores.put(ICdmIO.REFERENCE_STORE, new MapWrapper<ReferenceBase>(service));
  68                 stores.put(ICdmIO.NOMREF_STORE, new MapWrapper<ReferenceBase>(service));
  69                 stores.put(ICdmIO.NOMREF_DETAIL_STORE, new MapWrapper<ReferenceBase>(service));
  70                 stores.put(ICdmIO.REF_DETAIL_STORE, new MapWrapper<ReferenceBase>(service));
  71                 stores.put(ICdmIO.TAXONNAME_STORE, new MapWrapper<TaxonNameBase<?,?>>(service));
  72                 stores.put(ICdmIO.TAXON_STORE, new MapWrapper<TaxonBase>(service));
  73                 stores.put(ICdmIO.SPECIMEN_STORE, new MapWrapper<Specimen>(service));
  74         }
  75
  76         public boolean invoke(IImportConfigurator config){
  77                 if (config.getCheck().equals(IImportConfigurator.CHECK.CHECK_ONLY)){
  78                         return doCheck(config);
  79                 }else if (config.getCheck().equals(IImportConfigurator.CHECK.CHECK_AND_IMPORT)){
  80                         doCheck(config);
  81                         return doImport(config);
  82                 }else if (config.getCheck().equals(IImportConfigurator.CHECK.IMPORT_WITHOUT_CHECK)){
  83                         return doImport(config);
  84                 }else{
  85                         logger.error("Unknown CHECK type");
  86                         return false;
  87                 }
  88         }
  89
  90
  91         @SuppressWarnings("unchecked")
  92         protected <S extends IImportConfigurator> boolean doCheck(S  config){
  93                 boolean result = true;
  94                 System.out.println("Start checking Source ("+ config.getSourceNameString() + ") ...");
  95
  96                 //check
  97                 if (config == null){
  98                         logger.warn("CdmImportConfiguration is null");
  99                         return false;
 100                 }else if (! config.isValid()){
 101                         logger.warn("CdmImportConfiguration is not valid");
 102                         return false;
 103                 }
 104
 105                 ImportStateBase state = config.getNewState();
 106                 state.initialize(config);
 107
 108                 //do check for each class
 109                 for (Class<ICdmIO> ioClass: config.getIoClassList()){
 110                         try {
 111                                 String ioBeanName = getComponentBeanName(ioClass);
 112                                 ICdmIO cdmIo = (ICdmIO)applicationContext.getBean(ioBeanName, ICdmIO.class);
 113                                 if (cdmIo != null){
 114                                         result &= cdmIo.check(state);
 115                                 }else{
 116                                         logger.error("cdmIO was null");
 117                                         result = false;
 118                                 }
 119                         } catch (Exception e) {
 120                                         logger.error(e);
 121                                         e.printStackTrace();
 122                                         result = false;
 123                         }
 124                 }
 125
 126                 //return
 127                 System.out.println("End checking Source ("+ config.getSourceNameString() + ") for import to Cdm");
 128                 return result;
 129
 130         }
 131
 132
 133         /**
 134          * Executes the whole
 135          */
 136         protected <S extends IImportConfigurator>  boolean doImport(S config){
 137                 boolean result = true;
 138                 //validate
 139                 if (config == null){
 140                         logger.warn("Configuration is null");
 141                         return false;
 142                 }else if (! config.isValid()){
 143                         logger.warn("Configuration is not valid");
 144                         return false;
 145                 }
 146
 147                 ReferenceBase sourceReference = config.getSourceReference();
 148                 logger.info("Start import from Source '"+ config.getSourceNameString() + "' to destination '" + config.getDestinationNameString() + "'");
 149
 150                 ImportStateBase state = config.getNewState();
 151                 state.initialize(config);
 152
 153
 154                 //do invoke for each class
 155                 for (Class<ICdmIO> ioClass: config.getIoClassList()){
 156                         try {
 157                                 String ioBeanName = getComponentBeanName(ioClass);
 158                                 ICdmIO cdmIo = (ICdmIO)applicationContext.getBean(ioBeanName, ICdmIO.class);
 159                                 if (cdmIo != null){
 160 //                                      result &= cdmIo.invoke(config, stores);
 161                                         result &= cdmIo.invoke(state);
 162                                 }else{
 163                                         logger.error("cdmIO was null");
 164                                         result = false;
 165                                 }
 166                         } catch (Exception e) {
 167                                         logger.error(e);
 168                                         e.printStackTrace();
 169                                         result = false;
 170                         }
 171                 }
 172
 173                 //do invoke for each class
 174 //              for (String ioBean: config.getIoBeans()){
 175 //                      try {
 176 //                              ICdmIO<S> cdmIo = (ICdmIO<S>)applicationContext.getBean(ioBean, ICdmIO.class);
 177 //                              if (cdmIo != null){
 178 //                                      result &= cdmIo.invoke(config, stores);
 179 //                              }else{
 180 //                                      logger.error("cdmIO was null");
 181 //                                      result = false;
 182 //                              }
 183 //                      } catch (Exception e) {
 184 //                                      logger.error(e);
 185 //                                      e.printStackTrace();
 186 //                                      result = false;
 187 //                      }
 188 //
 189 //              }
 190
 191
 192                 logger.info("End import from source '" + config.getSourceNameString()
 193                                 + "' to destination '" + config.getDestinationNameString() + "'"+
 194                                 (result? "(successful)":"(with errors)")) ;
 195                 return result;
 196         }
 197
 198         private String getComponentBeanName(Class<ICdmIO> ioClass){
 199                 Component component = ioClass.getAnnotation(Component.class);
 200                 String ioBean = component.value();
 201                 if ("".equals(ioBean)){
 202                         ioBean = ioClass.getSimpleName();
 203                         ioBean = ioBean.substring(0, 1).toLowerCase() + ioBean.substring(1); //make camelcase
 204                 }
 205                 return ioBean;
 206         }
 207
 208 }