cdmlib-persistence/src/main/java/eu/etaxonomy/cdm/database/VocabularyStoreImpl.java

   1 /**
   2  *
   3  */
   4 package eu.etaxonomy.cdm.database;
   5
   6 import java.util.HashMap;
   7 import java.util.Iterator;
   8 import java.util.Map;
   9 import java.util.UUID;
  10
  11 import org.apache.log4j.Logger;
  12 import org.springframework.beans.factory.annotation.Autowired;
  13 import org.springframework.stereotype.Component;
  14 import org.springframework.transaction.annotation.Transactional;
  15
  16 import eu.etaxonomy.cdm.model.agent.Person;
  17 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  18 import eu.etaxonomy.cdm.model.common.Language;
  19 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  20 import eu.etaxonomy.cdm.model.common.init.IVocabularyStore;
  21 import eu.etaxonomy.cdm.model.common.init.TermLoader;
  22 import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
  23 import eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao;
  24
  25 /**
  26  * @author a.mueller
  27  *
  28  */
  29 @Component
  30 public class VocabularyStoreImpl implements IVocabularyStore {
  31         private static Logger logger = Logger.getLogger(VocabularyStoreImpl.class);
  32
  33         private boolean initialized = false;
  34
  35         private static final UUID uuidEnglish = UUID.fromString("e9f8cdb7-6819-44e8-95d3-e2d0690c3523");
  36
  37         public static final Language DEFAULT_LANGUAGE= makeDefaultLanguage();
  38         private static Language makeDefaultLanguage() {
  39                 Language defaultLanguage = new Language(uuidEnglish);
  40                 return defaultLanguage;
  41         }
  42
  43         static protected Map<UUID, DefinedTermBase> definedTermsMap = null;
  44
  45
  46         @Autowired
  47         public ITermVocabularyDao vocabularyDao;
  48
  49         @Autowired
  50         public IDefinedTermDao termDao;
  51
  52         /**
  53          *
  54          */
  55         public VocabularyStoreImpl() {
  56                 super();
  57         }
  58
  59
  60         /* (non-Javadoc)
  61          * @see eu.etaxonomy.cdm.model.common.init.IVocabularySaver#saveOrUpdate(eu.etaxonomy.cdm.model.common.TermVocabulary)
  62          */
  63         public void saveOrUpdate2(TermVocabulary<DefinedTermBase> vocabulary) {
  64                 initialize();
  65                 Iterator<DefinedTermBase> termIterator = vocabulary.iterator();
  66                 while (termIterator.hasNext()){
  67                         DefinedTermBase<DefinedTermBase> term = termIterator.next();
  68                         if (definedTermsMap.get(term.getUuid()) != null){
  69                                 term.setId(definedTermsMap.get(term.getUuid()).getId()); // to avoid duplicates in the default Language
  70                         }
  71                         definedTermsMap.put(term.getUuid(), term);
  72                 }
  73                 vocabularyDao.saveOrUpdate(vocabulary);
  74         }
  75
  76         public DefinedTermBase getTermByUuid(UUID uuid) {
  77                 if (initialize()){
  78                         if (definedTermsMap.get(uuid) != null){
  79                                 return definedTermsMap.get(uuid);
  80                         }else{
  81                                 DefinedTermBase term = termDao.findByUuid(uuid);
  82                                 definedTermsMap.put(term.getUuid(), term);
  83                                 return term;
  84                         }
  85                 }else{
  86                         logger.error("Vocabulary Store could not be initialized");
  87                         throw new RuntimeException("Vocabulary Store could not be initialized");
  88                 }
  89         }
  90
  91         public TermVocabulary<DefinedTermBase> getVocabularyByUuid(UUID uuid){
  92                 initialize();
  93                 return vocabularyDao.findByUuid(uuid);
  94         }
  95
  96         public boolean initialize(){
  97                 return loadBasicTerms();
  98         }
  99
 100         public boolean loadBasicTerms(){
 101                 if (! initialized){
 102                         logger.info("inititialize VocabularyStoreImpl ...");
 103                         try {
 104                                 Language defaultLanguage = (Language)termDao.findByUuid(DEFAULT_LANGUAGE.getUuid());
 105
 106                                 if (defaultLanguage == null){
 107                                         termDao.saveOrUpdate(DEFAULT_LANGUAGE);
 108                                         definedTermsMap = new HashMap<UUID, DefinedTermBase>();
 109                                         definedTermsMap.put(DEFAULT_LANGUAGE.getUuid(), DEFAULT_LANGUAGE);
 110                                         initialized = true;
 111                                         TermLoader termLoader = new TermLoader(this);
 112                                         termLoader.loadAllDefaultTerms();
 113                                 }else if (definedTermsMap == null){
 114                                                 definedTermsMap = new HashMap<UUID, DefinedTermBase>();
 115                                                 definedTermsMap.put(defaultLanguage.getUuid(), defaultLanguage);
 116                                 }
 117                         } catch (Exception e) {
 118                                 logger.error("loadBasicTerms: Error ocurred when initializing and loading terms");
 119                                 initialized = false;
 120                                 return false;
 121                         }
 122                         initialized = true;
 123                         logger.info("initTermsMap end ...");
 124                 }
 125                 return true;
 126         }
 127
 128 }