* 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.Set;
import java.util.TreeMap;
import java.util.UUID;
+import java.util.stream.Collectors;
import javax.persistence.EntityNotFoundException;
import org.apache.commons.collections.CollectionUtils;
-import org.apache.commons.lang.StringUtils;
-import org.apache.log4j.Logger;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import eu.etaxonomy.cdm.api.service.config.CreateHierarchyForClassificationConfigurator;
import eu.etaxonomy.cdm.api.service.config.NodeDeletionConfigurator.ChildHandling;
import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
-import eu.etaxonomy.cdm.api.service.dto.EntityDTO;
import eu.etaxonomy.cdm.api.service.dto.GroupedTaxonDTO;
import eu.etaxonomy.cdm.api.service.dto.MarkedEntityDTO;
import eu.etaxonomy.cdm.api.service.dto.TaxonInContextDTO;
import eu.etaxonomy.cdm.api.service.pager.impl.AbstractPagerImpl;
import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
+import eu.etaxonomy.cdm.compare.taxon.ITaxonNodeComparator;
+import eu.etaxonomy.cdm.compare.taxon.TaxonNodeSortMode;
import eu.etaxonomy.cdm.exception.FilterException;
import eu.etaxonomy.cdm.exception.UnpublishedException;
-import eu.etaxonomy.cdm.hibernate.HHH_9751_Util;
-import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.common.CdmBase;
-import eu.etaxonomy.cdm.model.common.DefinedTermBase;
import eu.etaxonomy.cdm.model.common.ITreeNode;
import eu.etaxonomy.cdm.model.common.MarkerType;
import eu.etaxonomy.cdm.model.common.TreeIndex;
import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.name.TaxonName;
-import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.taxon.Classification;
-import eu.etaxonomy.cdm.model.taxon.ITaxonNodeComparator;
import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
-import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
-import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
+import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;
import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonDao;
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;
+import eu.etaxonomy.cdm.persistence.dao.term.IDefinedTermDao;
import eu.etaxonomy.cdm.persistence.dto.ClassificationLookupDTO;
+import eu.etaxonomy.cdm.persistence.dto.EntityDTO;
import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;
import eu.etaxonomy.cdm.persistence.dto.TaxonStatus;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
public class ClassificationServiceImpl
extends IdentifiableServiceBase<Classification, IClassificationDao>
implements IClassificationService {
- private static final Logger logger = Logger.getLogger(ClassificationServiceImpl.class);
+
+ private static final Logger logger = LogManager.getLogger();
@Autowired
private ITaxonNodeDao taxonNodeDao;
this.dao = dao;
}
- private Comparator<? super TaxonNode> taxonNodeComparator;
+ private Comparator<TaxonNode> taxonNodeComparator;
@Autowired
- public void setTaxonNodeComparator(ITaxonNodeComparator<? super TaxonNode> taxonNodeComparator){
- this.taxonNodeComparator = (Comparator<? super TaxonNode>) taxonNodeComparator;
+ public void setTaxonNodeComparator(ITaxonNodeComparator<TaxonNode> taxonNodeComparator){
+ this.taxonNodeComparator = (Comparator<TaxonNode>) taxonNodeComparator;
}
@Override
return taxonNodeDao.load(taxonNodeUuid, propertyPaths);
}
- @Override
- @Transactional(readOnly = false)
- public UpdateResult cloneClassification(UUID classificationUuid,
- String name, Reference sec, TaxonRelationshipType relationshipType) {
- UpdateResult result = new UpdateResult();
- Classification classification = load(classificationUuid);
- Classification clone = Classification.NewInstance(name);
- clone.setReference(sec);
-
- //clone taxa and taxon nodes
- List<TaxonNode> childNodes = classification.getRootNode().getChildNodes();
- for (TaxonNode taxonNode : childNodes) {
- addChildTaxa(taxonNode, null, clone, relationshipType);
- }
- dao.saveOrUpdate(clone);
- result.setCdmEntity(clone);
- return result;
- }
-
- private void addChildTaxa(TaxonNode originalParentNode, TaxonNode cloneParentNode, Classification classification, TaxonRelationshipType relationshipType){
- Reference reference = classification.getReference();
- Taxon cloneTaxon = (Taxon) HibernateProxyHelper.deproxy(originalParentNode.getTaxon(), Taxon.class).clone();
- cloneTaxon.setSec(reference);
- String microReference = null;
- List<TaxonNode> originalChildNodes = originalParentNode.getChildNodes();
- HHH_9751_Util.removeAllNull(originalChildNodes);
-
- //add relation between taxa
- if (relationshipType != null){
- cloneTaxon.addTaxonRelation(originalParentNode.getTaxon(), relationshipType, reference, microReference);
- }
-
- TaxonNode cloneChildNode = null;
- //add taxon node to either parent node or classification (no parent node)
- if(cloneParentNode==null){
- cloneChildNode = classification.addChildTaxon(cloneTaxon, reference, microReference);
- }
- else{
- cloneChildNode = cloneParentNode.addChildTaxon(cloneTaxon, reference, microReference);
- }
- taxonNodeDao.saveOrUpdate(cloneChildNode);
- //add children
- for (TaxonNode originalChildNode : originalChildNodes) {
- addChildTaxa(originalChildNode, cloneChildNode, classification, relationshipType);
- }
- }
-
- @Override
- public List<TaxonNode> listRankSpecificRootNodes(Classification classification, Rank rank,
- boolean includeUnpublished, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {
- return listRankSpecificRootNodes(classification, null, rank, includeUnpublished, pageSize, pageIndex, propertyPaths);
- }
-
- /**
- * {@inheritDoc}
- */
@Override
public List<TaxonNode> listRankSpecificRootNodes(Classification classification,
TaxonNode subtree, Rank rank,
return pageRankSpecificRootNodes(classification, subtree, rank, includeUnpublished, pageSize, pageIndex, propertyPaths).getRecords();
}
+ @Override
+ public List<TaxonNodeDto> listRankSpecificRootNodeDtos(Classification classification, TaxonNode subtree,
+ Rank rank, boolean includeUnpublished, Integer pageSize, Integer pageIndex, TaxonNodeDtoSortMode sortMode,
+ List<String> propertyPaths) {
+ List<TaxonNode> list = listRankSpecificRootNodes(classification, subtree, rank, includeUnpublished, pageSize, pageIndex, propertyPaths);
+ return list.stream().filter(e -> e != null).map(e -> new TaxonNodeDto(e)).sorted(sortMode.comparator()).collect(Collectors.toList());
+ }
+
@Override
public Pager<TaxonNode> pageRankSpecificRootNodes(Classification classification, Rank rank,
boolean includeUnpublished, Integer pageSize, Integer pageIndex, List<String> propertyPaths) {
return loadTreeBranch(taxonNode, null, baseRank, includeUnpublished, propertyPaths);
}
- /**
- * {@inheritDoc}
- */
@Override
public List<TaxonNode> loadTreeBranch(TaxonNode taxonNode, TaxonNode subtree, Rank baseRank,
boolean includeUnpublished, List<String> propertyPaths) throws UnpublishedException{
return loadTreeBranchToTaxon(taxon, classification, null, baseRank, includeUnpublished, propertyPaths);
}
+ @Override
+ public List<TaxonNodeDto> loadTreeBranchDTOsToTaxon(Taxon taxon, Classification classification,
+ TaxonNode subtree, Rank baseRank,
+ boolean includeUnpublished, List<String> propertyPaths) throws UnpublishedException {
+ List<TaxonNode> list = loadTreeBranchToTaxon(taxon, classification, subtree, baseRank, includeUnpublished, propertyPaths);
+ return list.stream().map(e -> new TaxonNodeDto(e)).collect(Collectors.toList());
+ }
+
@Override
public List<TaxonNode> loadTreeBranchToTaxon(Taxon taxon, Classification classification,
TaxonNode subtree, Rank baseRank,
TaxonNode node = taxonNodeService.find(nodeUuid);
if(node == null){
logger.warn("The specified taxon is not found in the given tree.");
- return null;
+ return new ArrayList<>(0);
}else if (subtree != null && !node.isDescendant(subtree)){
//TODO handle as exception? E.g. FilterException, AccessDeniedException?
logger.warn("The specified taxon is not found for the given subtree.");
- return null;
+ return new ArrayList<>(0);
}
return loadTreeBranch(node, subtree, baseRank, includeUnpublished, propertyPaths);
return results;
}
+ @Override
+ public List<TaxonNodeDto> listChildNodeDtosOfTaxon(UUID taxonUuid, UUID classificationUuid,
+ UUID subtreeUuid, boolean includeUnpublished,
+ Integer pageSize, Integer pageIndex, TaxonNodeDtoSortMode sortMode) throws FilterException{
+
+ Classification classification = dao.load(classificationUuid);
+ Taxon taxon = (Taxon) taxonDao.load(taxonUuid);
+ TaxonNode subtree = taxonNodeDao.load(subtreeUuid);
+ if (subtreeUuid != null && subtree == null){
+ throw new FilterException("Taxon node for subtree filter can not be found in database", true);
+ }
+
+ List<TaxonNode> results = dao.listChildrenOf(
+ taxon, classification, subtree, includeUnpublished, pageSize, pageIndex, propertyPaths);
+ Comparator<TaxonNodeDto> comparator = sortMode.comparator();
+ // TODO order during the hibernate query in the dao?
+ List<TaxonNodeDto> dtos = results.stream()
+ .map(tn -> new TaxonNodeDto(tn))
+ .sorted(comparator)
+ .collect(Collectors.toList());
+ return dtos;
+ }
+
@Override
public Pager<TaxonNode> pageSiblingsOfTaxon(UUID taxonUuid, UUID classificationUuid, boolean includeUnpublished,
Integer pageSize, Integer pageIndex, List<String> propertyPaths){
return dao.list(limit, start, orderHints, propertyPaths);
}
- @Override
- public UUID removeTaxonNode(TaxonNode taxonNode) {
- return taxonNodeDao.delete(taxonNode);
- }
@Override
public UUID removeTreeNode(ITaxonTreeNode treeNode) {
if(treeNode instanceof Classification){
}
return null;
}
- @Override
- public UUID saveTaxonNode(TaxonNode taxonNode) {
- return taxonNodeDao.save(taxonNode).getUuid();
- }
@Override
public Map<UUID, TaxonNode> saveTaxonNodeAll(
}
@Override
- public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(UUID classificationUuid, Integer limit, String pattern, boolean searchForClassifications) {
- return taxonNodeDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(dao.load(classificationUuid), limit, pattern, searchForClassifications);
+ public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(UUID classificationUuid, Integer limit, String pattern, boolean searchForClassifications, boolean includeDoubtful) {
+ return taxonNodeDao.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(dao.load(classificationUuid), limit, pattern, searchForClassifications, includeDoubtful);
}
@Override
for (DescriptionElementBase descriptionElement: taxonDescription.getElements()){
for(Media media : descriptionElement.getMedia()){
//find the best matching representation
- mediaRepresentations.add(MediaUtils.findBestMatchingRepresentation(media,null, size, height, widthOrDuration, mimeTypes));
+ mediaRepresentations.add(MediaUtils.findBestMatchingRepresentation(media,null, size, height, widthOrDuration, mimeTypes, MediaUtils.MissingValueStrategy.MAX));
}
}
}
@Override
@Transactional(readOnly = false)
- public void updateTitleCache(Class<? extends Classification> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<Classification> cacheStrategy, IProgressMonitor monitor) {
+ public UpdateResult updateCaches(Class<? extends Classification> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<Classification> cacheStrategy, IProgressMonitor monitor) {
if (clazz == null){
clazz = Classification.class;
}
- super.updateTitleCacheImpl(clazz, stepSize, cacheStrategy, monitor);
+ return super.updateCachesImpl(clazz, stepSize, cacheStrategy, monitor);
}
/**
@Transactional(readOnly = false)
@Override
public UpdateResult createHierarchyInClassification(Classification classification, CreateHierarchyForClassificationConfigurator configurator){
+
UpdateResult result = new UpdateResult();
+ Set<TaxonNode> taxonNodesToSave = new HashSet<>();
+
classification = dao.findByUuid(classification.getUuid());
Map<String, List<TaxonNode>> map = getSortedGenusList(classification.getAllNodes());
//FIXME NPE for name
TaxonName name = tNode.getTaxon().getName();
if(name.getNameCache().equalsIgnoreCase(genus)){
- TaxonNode clone = (TaxonNode) tNode.clone();
+ TaxonNode clone = tNode.clone();
if(!tNode.hasChildNodes()){
//FIXME remove classification
// parentNode = newClassification.addChildNode(clone, 0, classification.getCitation(), classification.getMicroReference());
//get all childNodes
//save prior Hierarchy and remove them from the list
List<TaxonNode> copyAllChildrenToTaxonNode = copyAllChildrenToTaxonNode(tNode, clone, result);
-// parentNode = newClassification.addChildNode(clone, 0, classification.getCitation(), classification.getMicroReference());
- //FIXME remove classification
+// //FIXME remove classification
parentNode = newClassification.addChildNode(clone, 0, clone.getReference(), clone.getMicroReference());
//remove taxonNode from list because just added to classification
result.addUpdatedObject(tNode);
parentNode = newClassification.addChildTaxon(taxon, 0, null, null);
result.addUpdatedObject(parentNode);
}
- //iterate over the rest of the list
+ taxonNodesToSave.add(parentNode);
+
+ //iterate over the remaining list
for(TaxonNode tn : listOfTaxonNodes){
//if TaxonNode has a parent and this is not the classification then skip it
//and add to new classification via the parentNode as children of it
continue; //skip to next taxonNode
}
- TaxonNode clone = (TaxonNode) tn.clone();
+ TaxonNode clone = tn.clone();
//FIXME: citation from node
- //TODO: addchildNode without citation and references
-// TaxonNode taxonNode = parentNode.addChildNode(clone, classification.getCitation(), classification.getMicroReference());
+ //TODO: addChildNode without citation and references
TaxonNode taxonNode = parentNode.addChildNode(clone, clone.getReference(), clone.getMicroReference());
+ taxonNodesToSave.add(taxonNode);
+
result.addUnChangedObject(clone);
if(tn.hasChildNodes()){
//save hierarchy in new classification
}
}
dao.saveOrUpdate(newClassification);
+ taxonNodeDao.saveOrUpdateAll(taxonNodesToSave);
result.setCdmEntity(newClassification);
return result;
}
childNodes = copyFromNode.getChildNodes();
}
for(TaxonNode childNode:childNodes){
- TaxonNode clone = (TaxonNode) childNode.clone();
+ TaxonNode clone = childNode.clone();
result.addUnChangedObject(clone);
if(childNode.hasChildNodes()){
copyAllChildrenToTaxonNode(childNode, clone, result);
return childNodes;
}
- /**
- * {@inheritDoc}
- */
@Override
public ClassificationLookupDTO classificationLookup(Classification classification) {
return dao.classificationLookup(classification);
}
-
@Override
@Transactional
public DeleteResult delete(UUID classificationUuid, TaxonDeletionConfigurator config){
return result;
}
- /**
- * {@inheritDoc}
- */
@Override
public List<GroupedTaxonDTO> groupTaxaByMarkedParents(List<UUID> originalTaxonUuids, UUID classificationUuid,
MarkerType markerType, Boolean flag) {
//get all marked tree indexes
Set<TreeIndex> markedTreeIndexes = dao.getMarkedTreeIndexes(markerType, flag);
-
Map<TreeIndex, TreeIndex> groupedMap = TreeIndex.group(markedTreeIndexes, taxonIdTreeIndexMap.values());
Set<TreeIndex> notNullGroups = new HashSet<>(groupedMap.values());
notNullGroups.remove(null);
return result;
}
- /**
- * {@inheritDoc}
- */
@Override
public UUID getTaxonNodeUuidByTaxonUuid(UUID classificationUuid, UUID taxonUuid) {
Map<UUID, UUID> map = dao.getTaxonNodeUuidByTaxonUuid(classificationUuid, Arrays.asList(taxonUuid));
return taxonNodeUuid;
}
- /**
- * {@inheritDoc}
- */
@Override
public TaxonInContextDTO getTaxonInContext(UUID classificationUuid, UUID taxonBaseUuid,
Boolean doChildren, Boolean doSynonyms, boolean includeUnpublished, List<UUID> ancestorMarkers,
- NodeSortMode sortMode) {
+ TaxonNodeSortMode sortMode) {
+
TaxonInContextDTO result = new TaxonInContextDTO();
TaxonBase<?> taxonBase = taxonDao.load(taxonBaseUuid);
//children
if(! isSynonym) {
for (TaxonNodeDto childDto : children.getRecords()){
- if (doChildren && childDto.getStatus().equals(TaxonStatus.Accepted)){
+ if (doChildren && childDto.getTaxonStatus().equals(TaxonStatus.Accepted)){
EntityDTO<Taxon> child = new EntityDTO<Taxon>(childDto.getTaxonUuid(), childDto.getTitleCache());
result.addChild(child);
- }else if (doSynonyms && childDto.getStatus().isSynonym()){
+ }else if (doSynonyms && childDto.getTaxonStatus().isSynonym()){
EntityDTO<Synonym> child = new EntityDTO<>(childDto.getTaxonUuid(), childDto.getTitleCache());
result.addSynonym(child);
}
return result;
}
- /**
- * @param classificationUuid
- * @param acceptedTaxon
- * @return
- */
private Taxon getParentTaxon(UUID classificationUuid, Taxon acceptedTaxon) {
if (classificationUuid == null){
return null;
return null;
}
- /**
- * @param result
- * @param markerTypes
- * @param node
- */
private void handleAncestorsForMarkersRecursive(TaxonInContextDTO result, List<MarkerType> markerTypes, TaxonNode node) {
for (MarkerType type : markerTypes){
Taxon taxon = node.getTaxon();
}
}
- /**
- * {@inheritDoc}
- */
@Override
public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
Classification classification) {
return getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, false);
}
- /**
- * {@inheritDoc}
- */
@Override
public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
UUID classificationUuid) {
return getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classificationUuid, false);
}
- /**
- * {@inheritDoc}
- */
@Override
public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
UUID classificationUuid, Integer limit, String pattern) {
return getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classificationUuid, limit, pattern, false);
}
- /**
- * {@inheritDoc}
- */
@Override
public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
Classification classification, Integer limit, String pattern) {
return getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, limit, pattern, false);
}
+
+ @Override
+ public List<UuidAndTitleCache<TaxonNode>> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
+ UUID classificationUuid, Integer limit, String pattern, boolean searchForClassifications) {
+ return getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(
+ classificationUuid, limit, pattern, searchForClassifications, false);
+ }
}
BGBM BDI Projects / cdmlib.git / blobdiff