cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TermServiceImpl.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.cdm.api.service;
  12
  13 import java.util.ArrayList;
  14 import java.util.Collection;
  15 import java.util.Enumeration;
  16 import java.util.List;
  17 import java.util.Locale;
  18 import java.util.Map;
  19 import java.util.Set;
  20 import java.util.UUID;
  21
  22 import org.apache.log4j.Logger;
  23 import org.springframework.beans.factory.annotation.Autowired;
  24 import org.springframework.beans.factory.annotation.Qualifier;
  25 import org.springframework.stereotype.Service;
  26 import org.springframework.transaction.annotation.Transactional;
  27
  28 import eu.etaxonomy.cdm.api.service.pager.Pager;
  29 import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
  30 import eu.etaxonomy.cdm.model.common.DefinedTermBase;
  31 import eu.etaxonomy.cdm.model.common.Language;
  32 import eu.etaxonomy.cdm.model.common.LanguageString;
  33 import eu.etaxonomy.cdm.model.common.LanguageStringBase;
  34 import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
  35 import eu.etaxonomy.cdm.model.common.Representation;
  36 import eu.etaxonomy.cdm.model.common.TermVocabulary;
  37 import eu.etaxonomy.cdm.model.location.NamedArea;
  38 import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
  39 import eu.etaxonomy.cdm.model.location.NamedAreaType;
  40 import eu.etaxonomy.cdm.model.location.TdwgArea;
  41 import eu.etaxonomy.cdm.model.media.Media;
  42 import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
  43 import eu.etaxonomy.cdm.persistence.dao.common.ILanguageStringBaseDao;
  44 import eu.etaxonomy.cdm.persistence.dao.common.ILanguageStringDao;
  45 import eu.etaxonomy.cdm.persistence.dao.common.IRepresentationDao;
  46 import eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao;
  47
  48 @Service
  49 @Transactional(readOnly = true)
  50 public class TermServiceImpl extends ServiceBase<DefinedTermBase,IDefinedTermDao> implements ITermService{
  51         private static final Logger logger = Logger.getLogger(TermServiceImpl.class);
  52
  53         protected ITermVocabularyDao vocabularyDao;
  54         @Autowired
  55         @Qualifier("langStrBaseDao")
  56         private ILanguageStringBaseDao languageStringBaseDao;
  57         @Autowired
  58         private IRepresentationDao representationDao;
  59         @Autowired
  60         private ILanguageStringDao languageStringDao;
  61
  62         @Autowired
  63         protected void setVocabularyDao(ITermVocabularyDao vocabularyDao) {
  64                 this.vocabularyDao = vocabularyDao;
  65         }
  66
  67         /* (non-Javadoc)
  68          * @see eu.etaxonomy.cdm.api.service.ITermService#getTermByUri(java.lang.String)
  69          */
  70         public DefinedTermBase getTermByUri(String uri) {
  71                 //FIXME transformation from URI to UUID
  72                 return dao.findByUri(uri);
  73         }
  74
  75         /* FIXME candidate for harmonization(non-Javadoc)
  76          * @see eu.etaxonomy.cdm.api.service.ITermService#getTermByUuid(java.util.UUID)
  77          */
  78         public DefinedTermBase getTermByUuid(UUID uuid) {
  79                 return dao.findByUuid(uuid);
  80         }
  81
  82         public List<DefinedTermBase> getAllDefinedTerms(int limit, int start){
  83                 return dao.list(limit, start);
  84         }
  85
  86         @Transactional(readOnly = false)
  87         public UUID saveTerm(DefinedTermBase termBase) {
  88                 return super.saveCdmObject(termBase);
  89         }
  90
  91         @Transactional(readOnly = false)
  92         public Map<UUID, DefinedTermBase> saveTermsAll(Collection<? extends DefinedTermBase> termBaseCollection){
  93                 return saveCdmObjectAll(termBaseCollection);
  94         }
  95
  96         /* (non-Javadoc)
  97          * @see eu.etaxonomy.cdm.api.service.ITermService#getVocabulary(java.util.UUID)
  98          */
  99         public TermVocabulary getVocabulary(UUID vocabularyUuid) {
 100                 TermVocabulary vocabulary = (OrderedTermVocabulary)vocabularyDao.findByUuid(vocabularyUuid);
 101                 return vocabulary;
 102         }
 103
 104         /* (non-Javadoc)
 105          * @see eu.etaxonomy.cdm.api.service.ITermService#listVocabularies(java.lang.Class)
 106          */
 107         public Set<TermVocabulary> listVocabularies(Class termClass) {
 108                 logger.error("Method not implemented yet");
 109                 return null;
 110         }
 111
 112         public List<TermVocabulary<DefinedTermBase>> getAllTermVocabularies(int limit, int start) {
 113                 return vocabularyDao.list(limit, start);
 114         }
 115
 116         /* (non-Javadoc)
 117          * @see eu.etaxonomy.cdm.api.service.ITermService#getLanguageVocabulary()
 118          */
 119         public TermVocabulary<Language> getLanguageVocabulary() {
 120                 String uuidString = "45ac7043-7f5e-4f37-92f2-3874aaaef2de";
 121                 UUID uuid = UUID.fromString(uuidString);
 122                 TermVocabulary<Language> languageVocabulary =
 123                         (TermVocabulary)vocabularyDao.findByUuid(uuid);
 124                 return languageVocabulary;
 125         }
 126
 127         public Map<UUID, TermVocabulary<DefinedTermBase>>
 128     saveTermVocabulariesAll(Collection<TermVocabulary<DefinedTermBase>> termVocabularies) {
 129                 return vocabularyDao.saveAll(termVocabularies);
 130         }
 131
 132         public UUID saveTermVocabulary(TermVocabulary termVocabulary) {
 133                 return vocabularyDao.save(termVocabulary);
 134         }
 135
 136 //      @Transactional(readOnly = false)
 137 //      public Map<UUID, Representation> saveRepresentationsAll(Collection<Representation> representations){
 138 //              return representationDao.saveAll(representations);
 139 //      }
 140
 141         @Transactional(readOnly = false)
 142         public Map<UUID, LanguageStringBase> saveLanguageDataAll(Collection<LanguageStringBase> languageData) {
 143                 return languageStringBaseDao.saveAll(languageData);
 144         }
 145
 146         @Transactional(readOnly = false)
 147         public Map<UUID, Representation> saveRepresentationAll(Collection<Representation> representations) {
 148                 return representationDao.saveAll(representations);
 149         }
 150
 151         public List<Representation> getAllRepresentations(int limit, int start){
 152                 return representationDao.list(limit, start);
 153         }
 154
 155         public List<LanguageString> getAllLanguageStrings(int limit, int start) {
 156                 return languageStringDao.list(limit, start);
 157         }
 158
 159         public Map<UUID, LanguageStringBase>
 160                saveLanguageStringBasesAll(Collection<LanguageStringBase> languageStringBases) {
 161                 return languageStringBaseDao.saveAll(languageStringBases);
 162         }
 163
 164         public Language getLanguageByIso(String iso639) {
 165                 return dao.getLanguageByIso(iso639);
 166         }
 167
 168         public List<Language> getLanguagesByLocale(Enumeration<Locale> locales){
 169                 return dao.getLanguagesByLocale(locales);
 170         }
 171
 172         @Transactional(readOnly = false)
 173         public UUID saveLanguageData(
 174                         LanguageStringBase languageData) {
 175                         return languageStringBaseDao.save(languageData);
 176         }
 177
 178         @Autowired
 179         protected void setDao(IDefinedTermDao dao) {
 180                 this.dao = dao;
 181         }
 182
 183         /* (non-Javadoc)
 184          * @see eu.etaxonomy.cdm.api.service.ITermService#getAreaByTdwgAbbreviation(java.lang.String)
 185          */
 186         public NamedArea getAreaByTdwgAbbreviation(String tdwgAbbreviation) {
 187                 //FIXME this is just a placeholder until it is decided where to implement this method
 188                 //(see also FIXMEs in TdwgArea)
 189                 return TdwgArea.getAreaByTdwgAbbreviation(tdwgAbbreviation);
 190         }
 191
 192         public <T extends DefinedTermBase> Pager<T> getGeneralizationOf(T definedTerm, Integer pageSize, Integer pageNumber) {
 193         Integer numberOfResults = dao.countGeneralizationOf(definedTerm);
 194
 195                 List<T> results = new ArrayList<T>();
 196                 if(numberOfResults > 0) { // no point checking again
 197                         results = dao.getGeneralizationOf(definedTerm, pageSize, pageNumber);
 198                 }
 199
 200                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 201         }
 202
 203         public <T extends DefinedTermBase> Pager<T> getIncludes(Set<T> definedTerms, Integer pageSize, Integer pageNumber) {
 204         Integer numberOfResults = dao.countIncludes(definedTerms);
 205
 206                 List<T> results = new ArrayList<T>();
 207                 if(numberOfResults > 0) { // no point checking again
 208                         results = dao.getIncludes(definedTerms, pageSize, pageNumber);
 209                 }
 210
 211                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 212         }
 213
 214         public Pager<Media> getMedia(DefinedTermBase definedTerm, Integer pageSize,     Integer pageNumber) {
 215         Integer numberOfResults = dao.countMedia(definedTerm);
 216
 217                 List<Media> results = new ArrayList<Media>();
 218                 if(numberOfResults > 0) { // no point checking again
 219                         results = dao.getMedia(definedTerm, pageSize, pageNumber);
 220                 }
 221
 222                 return new DefaultPagerImpl<Media>(pageNumber, numberOfResults, pageSize, results);
 223         }
 224
 225         public <T extends DefinedTermBase> Pager<T> getPartOf(Set<T> definedTerms,Integer pageSize, Integer pageNumber) {
 226         Integer numberOfResults = dao.countPartOf(definedTerms);
 227
 228                 List<T> results = new ArrayList<T>();
 229                 if(numberOfResults > 0) { // no point checking again
 230                         results = dao.getPartOf(definedTerms, pageSize, pageNumber);
 231                 }
 232
 233                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 234         }
 235
 236         public Pager<NamedArea> list(NamedAreaLevel level, NamedAreaType type,  Integer pageSize, Integer pageNumber) {
 237         Integer numberOfResults = dao.count(level, type);
 238
 239                 List<NamedArea> results = new ArrayList<NamedArea>();
 240                 if(numberOfResults > 0) { // no point checking again
 241                         results = dao.list(level, type, pageSize, pageNumber);
 242                 }
 243
 244                 return new DefaultPagerImpl<NamedArea>(pageNumber, numberOfResults, pageSize, results);
 245         }
 246
 247
 248
 249 }