cdmlib-io/src/main/java/eu/etaxonomy/cdm/io/common/ImportConfiguratorBase.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 package eu.etaxonomy.cdm.io.common;
  10
  11 import java.lang.reflect.Method;
  12 import java.util.HashMap;
  13 import java.util.List;
  14 import java.util.Map;
  15 import java.util.UUID;
  16
  17 import org.joda.time.DateTime;
  18 import org.joda.time.format.DateTimeFormat;
  19 import org.joda.time.format.DateTimeFormatter;
  20 import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
  21 import org.springframework.stereotype.Component;
  22
  23 import eu.etaxonomy.cdm.database.DbSchemaValidation;
  24 import eu.etaxonomy.cdm.database.ICdmDataSource;
  25 import eu.etaxonomy.cdm.io.common.mapping.IInputTransformer;
  26 import eu.etaxonomy.cdm.model.agent.Person;
  27 import eu.etaxonomy.cdm.model.description.Feature;
  28 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  29 import eu.etaxonomy.cdm.model.reference.OriginalSourceType;
  30 import eu.etaxonomy.cdm.model.reference.Reference;
  31
  32 /**
  33  * @author a.mueller
  34  * @since 20.06.2008
  35  * @param <STATE> the import state
  36  */
  37 @Component
  38 public abstract class ImportConfiguratorBase<STATE extends ImportStateBase, SOURCE>
  39         extends IoConfiguratorBase
  40         implements IImportConfigurator {
  41
  42     private static final long serialVersionUID = 7223140465020160905L;
  43
  44     //check
  45         private CHECK check = CHECK.CHECK_AND_IMPORT;
  46
  47         //editor
  48         static EDITOR editor = EDITOR.EDITOR_AS_ANNOTATION;
  49
  50         /**
  51          * The transformer class to be used for Input
  52          */
  53         private IInputTransformer transformer;
  54
  55         private UUID uuidFeatureTree;
  56
  57         private String featureTreeTitle;
  58
  59         //Nomenclatural Code
  60         private NomenclaturalCode nomenclaturalCode = null;
  61
  62         private Map<Integer, Feature>  featureMap = new HashMap<>();
  63
  64          /* The classification name for the first classification.
  65           * Needs only to be defined if the import does not handle the naming
  66           * itself (e.g. by using the taxon sec. reference title cache)
  67           */
  68         private String classificationName = "Classification - no name";
  69
  70         private UUID  classificationUuid = UUID.randomUUID();
  71         //uuid of concept reference
  72         private UUID  secUuid = UUID.randomUUID();
  73
  74         private Object sourceSecId = -1;
  75
  76         private SOURCE source;
  77         protected Reference sourceReference;
  78         private UUID sourceRefUuid;
  79         private OriginalSourceType sourceType = OriginalSourceType.Import;
  80         private ICdmDataSource destination;
  81         private Person commentator =  Person.NewTitledInstance("automatic CDM importer");
  82
  83         @SuppressWarnings("rawtypes")
  84     protected Class<ICdmImport>[] ioClassList;
  85
  86         @SuppressWarnings("rawtypes")
  87     protected ICdmIO[] ioList;
  88
  89         protected String[] ioBeans;
  90
  91         /*user interaction*/
  92     private boolean askUserForHelp =false;
  93
  94 /* *****************CONSTRUCTOR *****************************/
  95
  96         protected ImportConfiguratorBase(IInputTransformer transformer){
  97                 setDbSchemaValidation(DbSchemaValidation.VALIDATE);
  98                 this.transformer = transformer;
  99         }
 100
 101         abstract protected void makeIoClassList();
 102
 103         @Override
 104     public IInputTransformer getTransformer() {
 105                 return this.transformer;
 106         }
 107         @Override
 108     public void setTransformer(IInputTransformer transformer){
 109                 this.transformer = transformer;
 110         }
 111
 112     @Override
 113     public SOURCE getSource() {
 114         return source;
 115     }
 116         public void setSource(SOURCE source) {
 117                 this.source = source;
 118         }
 119
 120         @Override
 121     public boolean isValid(){
 122                 boolean result = true;
 123                 if (getSource() == null){
 124                         //logger.warn("Connection to source could not be established");
 125                         result = false;
 126                 }
 127 //Not valid any more as the importer may already have a destination
 128 //              if (destination == null ){
 129 //                      logger.warn("Connection to Cdm could not be established");
 130 //                      result = false;
 131 //              }
 132
 133                 return result;
 134         }
 135
 136 /* ****************** GETTER/SETTER **************************/
 137
 138
 139         public void setIoClassList(ICdmImport[] ioList){
 140                 this.ioList = ioList;
 141         }
 142
 143         @Override
 144     public Class<ICdmImport>[] getIoClassList(){
 145                 if (ioClassList == null){
 146                         makeIoClassList();
 147                 }
 148                 return ioClassList;
 149         }
 150         public void setIoClassList(Class<ICdmImport>[] ioClassList){
 151                 this.ioClassList = ioClassList;
 152         }
 153
 154         @Override
 155     public CHECK getCheck() {
 156                 return this.check;
 157         }
 158         @Override
 159     public void setCheck(CHECK check) {
 160                 this.check = check;
 161         }
 162
 163         @Override
 164     public EDITOR getEditor() {
 165                 return editor;
 166         }
 167         @Override
 168     public void setEditor(EDITOR editor) {
 169                 ImportConfiguratorBase.editor = editor;
 170         }
 171
 172         @Override
 173     public ICdmDataSource getDestination() {
 174                 return destination;
 175         }
 176         @Override
 177     public void setDestination(ICdmDataSource destination) {
 178                 this.destination = destination;
 179         }
 180
 181         @Override
 182     public abstract Reference getSourceReference();
 183         @Override
 184     public void setSourceReference(Reference sourceReference) {
 185                 this.sourceReference = sourceReference;
 186         }
 187
 188         @Override
 189     public String getSourceReferenceTitle() {
 190                 return getSourceReference().getTitleCache();
 191         }
 192         @Override
 193     public void setSourceReferenceTitle(String sourceReferenceTitle) {
 194                 getSourceReference().setTitleCache(sourceReferenceTitle, true);
 195         }
 196
 197         @Override
 198     public Person getCommentator() {
 199                 return commentator;
 200         }
 201         @Override
 202     public void setCommentator(Person commentator) {
 203                 this.commentator = commentator;
 204         }
 205
 206         @Override
 207     public NomenclaturalCode getNomenclaturalCode() {
 208                 return nomenclaturalCode;
 209         }
 210         @Override
 211     public void setNomenclaturalCode(NomenclaturalCode nomenclaturalCode) {
 212                 this.nomenclaturalCode = nomenclaturalCode;
 213         }
 214
 215         @Override
 216     public UUID getClassificationUuid() {
 217                 return classificationUuid;
 218         }
 219         @Override
 220     public void setClassificationUuid(UUID classificationUuid) {
 221                 this.classificationUuid = classificationUuid;
 222         }
 223
 224         @Override
 225     public UUID getSecUuid() {
 226                 return secUuid;
 227         }
 228         @Override
 229     public void setSecUuid(UUID secUuid) {
 230                 this.secUuid = secUuid;
 231         }
 232
 233         @Override
 234     public Object getSourceSecId() {
 235                 return sourceSecId;
 236         }
 237         public void setSourceSecId(Object sourceSecId) {
 238                 this.sourceSecId = sourceSecId;
 239         }
 240
 241         public Map<Integer, Feature>  getFeatureMap() {
 242                 return featureMap;
 243         }
 244         public void setFeatureMap(Map<Integer, Feature>  featureMap) {
 245                 this.featureMap = featureMap;
 246         }
 247
 248         protected static Method getDefaultFunction(Class<?> clazz, String methodName){
 249                 try {
 250                         return clazz.getMethod(methodName, List.class) ;
 251                 } catch (SecurityException e) {
 252                         e.printStackTrace();
 253                 } catch (NoSuchMethodException e) {
 254                         e.printStackTrace();
 255                 }
 256                 return null;
 257         }
 258
 259         @Override
 260     public String getDestinationNameString() {
 261                 if (this.getDestination() == null) {
 262                         return null;
 263                 } else {
 264                         return this.getDestination().getName().toString();
 265                 }
 266         }
 267
 268         @Override
 269     public String getSourceNameString() {
 270                 if (this.getSource() == null){
 271                         return null;
 272                 }else{
 273                         return this.getSource().toString();
 274                 }
 275         }
 276
 277         /**
 278          * The classification name for the first classification.
 279          * Needs only to be defined if the import does not handle the naming
 280          * itself (e.g. by using the taxon sec. reference title cache)
 281          */
 282         public void setClassificationName(String classificationName) {
 283                 this.classificationName = classificationName;
 284         }
 285         public String getClassificationName() {
 286                 return classificationName;
 287         }
 288
 289         public UUID getSourceRefUuid() {
 290                 return sourceRefUuid;
 291         }
 292         public void setSourceRefUuid(UUID sourceRefUuid) {
 293                 this.sourceRefUuid = sourceRefUuid;
 294         }
 295
 296         public OriginalSourceType getSourceType() {
 297         return sourceType;
 298     }
 299     public void setSourceType(OriginalSourceType sourceType) {
 300         this.sourceType = sourceType;
 301     }
 302
 303     @Override
 304         public boolean isOmitTermLoading() {
 305                 return false;
 306         }
 307
 308         @Override
 309         public boolean isCreateNew(){
 310                 return false;
 311         }
 312
 313         @Override
 314     public UsernamePasswordAuthenticationToken getAuthenticationToken(){
 315                 return this.authenticationToken;
 316         }
 317
 318         /*user interaction*/
 319         public boolean isInteractWithUser() {
 320         return askUserForHelp;
 321     }
 322     public void setInteractWithUser (boolean interaction){
 323         askUserForHelp=interaction;
 324     }
 325
 326     public UUID getUuidFeatureTree() {
 327         return uuidFeatureTree;
 328     }
 329     public void setUuidFeatureTree(UUID uuidFeatureTree) {
 330         this.uuidFeatureTree = uuidFeatureTree;
 331     }
 332
 333     public String getFeatureTreeTitle() {
 334         return featureTreeTitle;
 335     }
 336     public void setFeatureTreeTitle(String featureTreeTitle) {
 337         this.featureTreeTitle = featureTreeTitle;
 338     }
 339
 340     private static final DateTimeFormatter formatter = DateTimeFormat.forPattern("YYYY-MM-dd");
 341
 342     protected String getDateString(){
 343         return formatter.print(new DateTime());
 344     }
 345
 346     /**
 347      * If <code>false</code> auditing is switched off during import.
 348      * This is only applicable if an own application context is started
 349      * for the import/export. For imports into/from running application contexts
 350      * it has no effect.
 351      */
 352     public boolean isRegisterAuditing() {
 353         return hibernateConfig.getRegisterEnvers();
 354     }
 355     /**
 356      * @see #isRegisterAuditing()
 357      */
 358     public void setRegisterAuditing(boolean registerAuditing) {
 359         this.hibernateConfig.setRegisterEnvers(registerAuditing);
 360     }
 361 }