X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/199ed72a78b464290b2470e7f5dc823a1373d6aa..f8b73f93a26ee9ac99bd64a45f89271001eb7222:/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/VocabularyServiceImpl.java diff --git a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/VocabularyServiceImpl.java b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/VocabularyServiceImpl.java index 060d04e75c..4e07788574 100644 --- a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/VocabularyServiceImpl.java +++ b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/VocabularyServiceImpl.java @@ -1,103 +1,204 @@ -/** -* Copyright (C) 2009 EDIT -* European Distributed Institute of Taxonomy -* http://www.e-taxonomy.eu -* -* The contents of this file are subject to the Mozilla Public License Version 1.1 -* See LICENSE.TXT at the top of this package for the full license terms. -*/ - -package eu.etaxonomy.cdm.api.service; - -import java.util.ArrayList; -import java.util.List; -import java.util.UUID; - -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.stereotype.Service; -import org.springframework.transaction.annotation.Propagation; -import org.springframework.transaction.annotation.Transactional; - -import eu.etaxonomy.cdm.api.service.pager.Pager; -import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl; -import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; -import eu.etaxonomy.cdm.model.common.DefinedTermBase; -import eu.etaxonomy.cdm.model.common.Language; -import eu.etaxonomy.cdm.model.common.TermType; -import eu.etaxonomy.cdm.model.common.TermVocabulary; -import eu.etaxonomy.cdm.model.common.VocabularyEnum; -import eu.etaxonomy.cdm.persistence.dao.common.ITermVocabularyDao; -import eu.etaxonomy.cdm.persistence.query.OrderHint; -import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; - -@Service -@Transactional(readOnly = true) -public class VocabularyServiceImpl extends IdentifiableServiceBase implements IVocabularyService { - - @Autowired - protected void setDao(ITermVocabularyDao dao) { - this.dao = dao; - } - - - /* (non-Javadoc) - * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy) - */ - @Override - @Transactional(readOnly = false) - public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { - if (clazz == null){ - clazz = TermVocabulary.class; - } - super.updateTitleCacheImpl(clazz, stepSize, cacheStrategy, monitor); - } - - - public TermVocabulary getVocabulary(VocabularyEnum vocabularyType){ - return dao.findByUuid(vocabularyType.getUuid()); - } - - /* (non-Javadoc) - * @see eu.etaxonomy.cdm.api.service.IVocabularyService#listByTermClass(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) - */ - @Override - public List> listByTermClass(Class clazz, Integer limit, Integer start, List orderHints, List propertyPaths) { - boolean includeSubclasses = false; - boolean includeEmptyVocs = false; - return (List)listByTermClass(clazz, includeSubclasses, includeEmptyVocs, limit, start, orderHints, propertyPaths); - } - - public List> listByTermClass(Class clazz, boolean includeSubclasses, boolean includeEmptyVocs, Integer limit, Integer start, List orderHints, List propertyPaths) { - return dao.listByTermClass(clazz, includeSubclasses, includeEmptyVocs,limit, start, orderHints, propertyPaths); - } - - public List> findByTermType(TermType termType) { - return dao.findByTermType(termType); - } - /** - * (non-Javadoc) - * @see eu.etaxonomy.cdm.api.service.ITermService#getLanguageVocabulary() - * FIXME candidate for harmonization - * is this the same as getVocabulary(VocabularyEnum.Language) - */ - public TermVocabulary getLanguageVocabulary() { - String uuidString = "45ac7043-7f5e-4f37-92f2-3874aaaef2de"; - UUID uuid = UUID.fromString(uuidString); - TermVocabulary languageVocabulary = (TermVocabulary)dao.findByUuid(uuid); - return languageVocabulary; - } - - public Pager getTerms(TermVocabulary vocabulary, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { - Integer numberOfResults = dao.countTerms(vocabulary); - - List results = new ArrayList(); - if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) - results = dao.getTerms(vocabulary, pageSize, pageNumber,orderHints,propertyPaths); - } - - return new DefaultPagerImpl(pageNumber, numberOfResults, pageSize, results); - } - - - -} +/** +* Copyright (C) 2009 EDIT +* European Distributed Institute of Taxonomy +* http://www.e-taxonomy.eu +* +* The contents of this file are subject to the Mozilla Public License Version 1.1 +* See LICENSE.TXT at the top of this package for the full license terms. +*/ +package eu.etaxonomy.cdm.api.service; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Set; +import java.util.UUID; + +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +import eu.etaxonomy.cdm.api.service.pager.Pager; +import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl; +import eu.etaxonomy.cdm.common.monitor.IProgressMonitor; +import eu.etaxonomy.cdm.model.common.CdmClass; +import eu.etaxonomy.cdm.model.common.Language; +import eu.etaxonomy.cdm.model.term.DefinedTermBase; +import eu.etaxonomy.cdm.model.term.TermType; +import eu.etaxonomy.cdm.model.term.TermVocabulary; +import eu.etaxonomy.cdm.persistence.dao.term.ITermVocabularyDao; +import eu.etaxonomy.cdm.persistence.dto.TermDto; +import eu.etaxonomy.cdm.persistence.dto.TermVocabularyDto; +import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; + +@Service +@Transactional(readOnly = true) +public class VocabularyServiceImpl extends IdentifiableServiceBase implements IVocabularyService { + + @Autowired + private ITermService termService; + + @Override + @Autowired + protected void setDao(ITermVocabularyDao dao) { + this.dao = dao; + } + + @Override + @Transactional(readOnly = false) + public UpdateResult updateCaches(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + if (clazz == null){ + clazz = TermVocabulary.class; + } + return super.updateCachesImpl(clazz, stepSize, cacheStrategy, monitor); + } + + @Override + public List listByTermType(TermType termType, boolean includeSubTypes, + Integer limit, Integer start, List orderHints, List propertyPaths) { + return dao.listByTermType(termType, includeSubTypes, limit, start, orderHints, propertyPaths); + } + + @Override + public List> findByTermType(TermType termType, List propertyPaths) { + return dao.findByTermType(termType, propertyPaths); + } + /** + * (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.ITermService#getLanguageVocabulary() + * FIXME candidate for harmonization + * is this the same as getVocabulary(VocabularyEnum.Language) + */ + @Override + public TermVocabulary getLanguageVocabulary() { + String uuidString = "45ac7043-7f5e-4f37-92f2-3874aaaef2de"; + UUID uuid = UUID.fromString(uuidString); + TermVocabulary languageVocabulary = dao.findByUuid(uuid); + return languageVocabulary; + } + + @Override + public Pager getTerms(TermVocabulary vocabulary, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + long numberOfResults = dao.countTerms(vocabulary); + + List results = new ArrayList<>(); + if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) + results = dao.getTerms(vocabulary, pageSize, pageNumber,orderHints,propertyPaths); + } + + return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results); + } + + + @Override + public Collection getTopLevelTerms(UUID vocabularyUuid) { + return dao.getTopLevelTerms(vocabularyUuid); + } + + @Override + public Collection getTerms(UUID vocabularyUuid) { + return dao.getTerms(vocabularyUuid); + } + + @Override + public Collection getTerms(List vocabularyUuids) { + return dao.getTerms(vocabularyUuids); + } + + @Override + public Collection getNamedAreaTerms(List vocabularyUuids) { + return dao.getNamedAreaTerms(vocabularyUuids); + } + + @Override + public List getCompleteTermHierarchy(TermVocabularyDto vocabularyDto) { + List topLevelTerms = dao.getTopLevelTerms(vocabularyDto.getUuid(), vocabularyDto.getTermType()); + for (TermDto termDto : topLevelTerms) { + termDto.setVocabularyDto(vocabularyDto); + initializeIncludes(termDto); + initializeGeneralizationOf(termDto); + } + + return topLevelTerms; + } + + private void initializeGeneralizationOf(TermDto parentTerm){ + Collection generalizationOf = termService.getKindOfsAsDto(parentTerm); + parentTerm.setGeneralizationOf(generalizationOf); + generalizationOf.forEach(generalization->{ + generalization.setVocabularyDto(parentTerm.getVocabularyDto()); + generalization.setKindOfDto(parentTerm); + initializeGeneralizationOf(generalization); + }); + } + + private void initializeIncludes(TermDto parentTerm){ + Collection includes = termService.getIncludesAsDto(parentTerm); + parentTerm.setIncludes(includes); + includes.forEach(include->{ + include.setVocabularyDto(parentTerm.getVocabularyDto()); + initializeIncludes(include); + include.setPartOfDto(parentTerm); + }); + } + + @Override + public List findVocabularyDtoByTermType(TermType termType) { + return findVocabularyDtoByTermTypes(Collections.singleton(termType), true); + } + + @Override + public List findVocabularyDtoByTermTypeAndPattern(String pattern, TermType termType) { + return dao.findVocabularyDtoByTermTypes(Collections.singleton(termType), pattern, true); + } + + @Override + public List findVocabularyDtoByTermTypes(Set termTypes) { + return findVocabularyDtoByTermTypes(termTypes, true); + } + + @Override + public List findVocabularyDtoByTermType(TermType termType, boolean includeSubtypes) { + return findVocabularyDtoByTermTypes(Collections.singleton(termType), includeSubtypes); + } + + @Override + public List findVocabularyDtoByTermTypes(Set termTypes, boolean includeSubtypes) { + return dao.findVocabularyDtoByTermTypes(termTypes, includeSubtypes); + } + + @Override + public List findFeatureVocabularyDtoByTermTypes(Set availableFor) { + return dao.findVocabularyDtoByAvailableFor(availableFor); + } + + @Override + public TermVocabularyDto findVocabularyDtoByVocabularyUuid(UUID vocUuid) { + return dao.findVocabularyDtoByUuid(vocUuid); + } + + @Transactional(readOnly = false) + @Override + public TermDto addNewTerm(TermType termType, UUID vocabularyUUID) { + DefinedTermBase term = termType.getEmptyDefinedTermBase(); + termService.save(term); + TermVocabulary vocabulary = dao.load(vocabularyUUID); + vocabulary.addTerm(term); + dao.saveOrUpdate(vocabulary); + return TermDto.fromTerm(term, true); + } + + @Override + public List> getUuidAndTitleCache(Class clazz, TermType termType, + Integer limit, String pattern) { + return dao.getUuidAndTitleCache(clazz, termType, limit, pattern); + } + + @Override + public List findVocabularyDtoByVocabularyUuids(List vocUuids) { + return dao.findVocabularyDtoByUuids(vocUuids); + } +}