cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/common/init/TermLoader.java

   1 package eu.etaxonomy.cdm.model.common.init;
   2
   3 import java.io.FileNotFoundException;
   4 import java.io.InputStream;
   5 import java.io.InputStreamReader;
   6 import java.util.ArrayList;
   7 import java.util.HashMap;
   8 import java.util.List;
   9 import java.util.Map;
  10 import java.util.UUID;
  11
  12 import org.apache.log4j.Logger;
  13 import org.springframework.beans.factory.annotation.Autowired;
  14 import org.springframework.stereotype.Component;
  15 import org.springframework.transaction.annotation.Transactional;
  16
  17 import au.com.bytecode.opencsv.CSVReader;
  18 import eu.etaxonomy.cdm.common.CdmUtils;
  19
  20 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  21 import eu.etaxonomy.cdm.model.common.ILoadableTerm;
  22 import eu.etaxonomy.cdm.model.common.Language;
  23 import eu.etaxonomy.cdm.model.common.MarkerType;
  24 import eu.etaxonomy.cdm.model.common.NoDefinedTermClassException;
  25 import eu.etaxonomy.cdm.model.common.OrderedTermBase;
  26 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  27 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  28 import eu.etaxonomy.cdm.model.description.Feature;
  29 import eu.etaxonomy.cdm.model.location.Continent;
  30 import eu.etaxonomy.cdm.model.location.NamedArea;
  31 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  32 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  33 import eu.etaxonomy.cdm.model.location.TdwgArea;
  34 import eu.etaxonomy.cdm.model.location.WaterbodyOrCountry;
  35 import eu.etaxonomy.cdm.model.name.HybridRelationshipType;
  36 import eu.etaxonomy.cdm.model.name.NameRelationshipType;
  37 import eu.etaxonomy.cdm.model.name.NomenclaturalCode;
  38 import eu.etaxonomy.cdm.model.name.NomenclaturalStatusType;
  39 import eu.etaxonomy.cdm.model.name.Rank;
  40 import eu.etaxonomy.cdm.model.name.TypeDesignationStatus;
  41 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  42 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
  43
  44 @Component
  45 @Transactional(readOnly = false)
  46 public class TermLoader {
  47         private static final Logger logger = Logger.getLogger(TermLoader.class);
  48
  49         @Autowired
  50         private IVocabularyStore vocabularyStore;
  51
  52
  53         //TODO private -but Autowiring for constructor arguments is needed then for classes that use this class autowired (e.g. CdmTermInitializer)
  54         @Deprecated //because still public
  55         public TermLoader(){
  56                 super();
  57         }
  58         public void setVocabularyStore(IVocabularyStore vocabularyStore){
  59                 this.vocabularyStore = vocabularyStore;
  60         }
  61
  62
  63
  64         public TermLoader(IVocabularyStore vocabularyStore){
  65                 super();
  66                 this.vocabularyStore = vocabularyStore;
  67         }
  68
  69
  70         // load a list of defined terms from a simple text file
  71         // if isEnumeration is true an Enumeration for the ordered term list will be returned
  72         @Transactional(readOnly = false)
  73         public TermVocabulary<DefinedTermBase> insertTerms(Class<ILoadableTerm> termClass, String filename, boolean isEnumeration, boolean isOrdered) throws NoDefinedTermClassException, FileNotFoundException {
  74                 DefinedTermBase.setVocabularyStore(vocabularyStore); //otherwise DefinedTermBase is not able to find DefaultLanguage
  75                 try {
  76                         String strResourceFileName = "terms" + CdmUtils.getFolderSeperator() + filename;
  77                         logger.debug("strResourceFileName is " + strResourceFileName);
  78                         InputStream inputStream = CdmUtils.getReadableResourceStream("terms" + CdmUtils.getFolderSeperator() + filename);
  79                         if (inputStream == null) {logger.info("inputStream is null");}
  80                         CSVReader reader = new CSVReader(new InputStreamReader(inputStream));
  81
  82                         //vocabulary
  83                         TermVocabulary voc = null;
  84                         String labelAbbrev = null;
  85                         if (isOrdered){
  86                                 voc = new OrderedTermVocabulary<OrderedTermBase>(termClass.getCanonicalName(), termClass.getSimpleName(), labelAbbrev, termClass.getCanonicalName());
  87                         }else{
  88                                 voc = new TermVocabulary<DefinedTermBase>(termClass.getCanonicalName(), termClass.getSimpleName(), labelAbbrev, termClass.getCanonicalName());
  89                         }
  90                         String [] nextLine = reader.readNext();
  91                         if (nextLine != null){
  92                                 voc.readCsvLine(arrayedLine(nextLine));
  93                         }
  94                         saveVocabulary(voc, termClass);
  95                         //terms
  96                         while ((nextLine = reader.readNext()) != null) {
  97                                 // nextLine[] is an array of values from the line
  98                                 if (nextLine.length == 0){
  99                                         continue;
 100                                 }
 101                                 ILoadableTerm term = termClass.newInstance();
 102                                 term = term.readCsvLine(arrayedLine(nextLine));
 103                                 term.setVocabulary(voc);
 104                                 vocabularyStore.saveOrUpdate(term);
 105                                 // save enumeration and all terms to DB
 106                         }
 107                         return voc;
 108                 } catch (Exception e) {
 109                         logger.error(e.getMessage());
 110                         e.printStackTrace();
 111                         return null;
 112                 }
 113         }
 114
 115         private List<String> arrayedLine(String [] nextLine){
 116                 ArrayList<String> csvTermAttributeList = new ArrayList<String>(10);
 117                 for (String col : nextLine){
 118                         csvTermAttributeList.add(col);
 119                 }
 120                 while (csvTermAttributeList.size()<10){
 121                         csvTermAttributeList.add("");
 122                 }
 123                 return csvTermAttributeList;
 124         }
 125
 126
 127         private void saveVocabulary(TermVocabulary voc, Class<ILoadableTerm> termClass){
 128                 if (vocabularyStore != null){
 129                         vocabularyStore.saveOrUpdate(voc);
 130                 }else{
 131                         //e.g. in tests when no database connection exists
 132                         if (logger.isDebugEnabled()) {logger.debug("No vocabularyStore exists. Vocabulary for class '" + termClass +  "' could not be saved to database");}
 133                 }
 134
 135         }
 136
 137         public TermVocabulary<DefinedTermBase> insertDefaultTerms(Class termClass, boolean isOrdered) throws NoDefinedTermClassException, FileNotFoundException {
 138                 return insertDefaultTerms(termClass, termClass.getSimpleName()+".csv", isOrdered );
 139         }
 140
 141         public TermVocabulary<DefinedTermBase> insertDefaultTerms(Class termClass, String csvName, boolean isOrdered) throws NoDefinedTermClassException, FileNotFoundException {
 142                 if (termClass != null){logger.info("load file " + csvName);}
 143                 return this.insertTerms(termClass, csvName, true, isOrdered );
 144         }
 145
 146         public boolean insertDefaultTerms() throws FileNotFoundException, NoDefinedTermClassException{
 147                 final boolean ORDERED = true;
 148                 final boolean NOT_ORDERED = false;
 149
 150                 logger.info("load terms");
 151                 insertDefaultTerms(Language.class, NOT_ORDERED);
 152                 insertDefaultTerms(WaterbodyOrCountry.class, NOT_ORDERED);
 153                 insertDefaultTerms(Continent.class, NOT_ORDERED);
 154                 insertDefaultTerms(Rank.class, ORDERED);
 155                 insertDefaultTerms(TypeDesignationStatus.class, ORDERED);
 156                 insertDefaultTerms(NomenclaturalStatusType.class, ORDERED);
 157                 insertDefaultTerms(SynonymRelationshipType.class, ORDERED);
 158                 insertDefaultTerms(HybridRelationshipType.class, ORDERED);
 159                 insertDefaultTerms(NameRelationshipType.class, ORDERED);
 160                 insertDefaultTerms(TaxonRelationshipType.class, ORDERED);
 161                 insertDefaultTerms(MarkerType.class, NOT_ORDERED);
 162                 insertDefaultTerms(NamedAreaType.class, NOT_ORDERED);
 163                 insertDefaultTerms(NamedAreaLevel.class, NOT_ORDERED);
 164                 insertDefaultTerms(NomenclaturalCode.class, NOT_ORDERED);
 165                 insertDefaultTerms(Feature.class, NOT_ORDERED);
 166                 insertDefaultTerms(NamedArea.class, "TdwgArea.csv", ORDERED);
 167                 logger.debug("terms loaded");
 168                 return true;
 169         }
 170
 171
 172         public boolean makeDefaultTermsInserted() throws FileNotFoundException, NoDefinedTermClassException{
 173                 return makeDefaultTermsInserted(vocabularyStore);
 174         }
 175
 176         public boolean makeDefaultTermsInserted(IVocabularyStore vocabularyStore) throws FileNotFoundException, NoDefinedTermClassException{
 177                 if (vocabularyStore == null){
 178                         vocabularyStore = this.vocabularyStore;
 179                 }
 180                 if (! checkBasicTermsExist(vocabularyStore)){
 181                         return insertDefaultTerms();
 182                 }
 183                 return true;
 184         }
 185
 186         /**
 187          * True, if some of the important basic terms are accessible by saver
 188          * @param saver
 189          * @return
 190          */
 191         private boolean checkBasicTermsExist(IVocabularyStore vocabularyStore){
 192                 if (vocabularyStore == null){
 193                         vocabularyStore = this.vocabularyStore;
 194                 }
 195                 if (vocabularyStore == null){
 196                         return false;
 197                 }
 198                 Map<String, UUID> allImportantUuid = new HashMap<String,UUID>();
 199                 allImportantUuid.put("English", UUID.fromString("e9f8cdb7-6819-44e8-95d3-e2d0690c3523"));
 200                 allImportantUuid.put("Rank", UUID.fromString("1b11c34c-48a8-4efa-98d5-84f7f66ef43a"));
 201                 for (UUID uuid: allImportantUuid.values()){
 202                         if (! checkTermExists(uuid, vocabularyStore)){
 203                                 return false;
 204                         }
 205                 }
 206                 return true;
 207         }
 208
 209         private boolean checkTermExists(UUID uuid, IVocabularyStore vocabularyStore){
 210                 if (vocabularyStore == null){
 211                         return false;
 212                 }
 213                 ILoadableTerm basicTerm = vocabularyStore.getTermByUuid(uuid);
 214                 if ( basicTerm == null || ! basicTerm.getUuid().equals(uuid)){
 215                         return false;
 216                 }else{
 217                         return true;
 218                 }
 219
 220         }
 221
 222 }