X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/a31759edae6ba1c48dc61e3dd8daed91c5b24e18..08183f9940eba2215352b890199303f20046713a:/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TermServiceImpl.java diff --git a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TermServiceImpl.java b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TermServiceImpl.java index 2951624761..b6cbe06b8f 100644 --- a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TermServiceImpl.java +++ b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TermServiceImpl.java @@ -1,4 +1,3 @@ -// $Id$ /** * Copyright (C) 2007 EDIT * European Distributed Institute of Taxonomy @@ -15,9 +14,9 @@ import java.util.ArrayList; import java.util.Collection; import java.util.Enumeration; import java.util.HashSet; -import java.util.Iterator; import java.util.List; import java.util.Locale; +import java.util.Map; import java.util.Set; import java.util.UUID; @@ -36,13 +35,15 @@ import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableExcepti 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.hibernate.HibernateProxyHelper; import eu.etaxonomy.cdm.model.common.CdmBase; import eu.etaxonomy.cdm.model.common.DefinedTermBase; import eu.etaxonomy.cdm.model.common.Language; import eu.etaxonomy.cdm.model.common.LanguageString; import eu.etaxonomy.cdm.model.common.LanguageStringBase; +import eu.etaxonomy.cdm.model.common.OrderedTermBase; +import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary; import eu.etaxonomy.cdm.model.common.Representation; -import eu.etaxonomy.cdm.model.common.TermBase; import eu.etaxonomy.cdm.model.common.TermType; import eu.etaxonomy.cdm.model.common.TermVocabulary; import eu.etaxonomy.cdm.model.location.NamedArea; @@ -53,6 +54,8 @@ import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao; import eu.etaxonomy.cdm.persistence.dao.common.ILanguageStringBaseDao; import eu.etaxonomy.cdm.persistence.dao.common.ILanguageStringDao; import eu.etaxonomy.cdm.persistence.dao.common.IRepresentationDao; +import eu.etaxonomy.cdm.persistence.dto.TermDto; +import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache; import eu.etaxonomy.cdm.persistence.query.OrderHint; import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; @@ -64,6 +67,9 @@ public class TermServiceImpl extends IdentifiableServiceBase Pager getGeneralizationOf(T definedTerm, Integer pageSize, Integer pageNumber) { - Integer numberOfResults = dao.countGeneralizationOf(definedTerm); + long numberOfResults = dao.countGeneralizationOf(definedTerm); - List results = new ArrayList(); + List results = new ArrayList<>(); if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) results = dao.getGeneralizationOf(definedTerm, pageSize, pageNumber); } - return new DefaultPagerImpl(pageNumber, numberOfResults, pageSize, results); + return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results); } @Override public Pager getIncludes(Collection definedTerms, Integer pageSize, Integer pageNumber, List propertyPaths) { - Integer numberOfResults = dao.countIncludes(definedTerms); + long numberOfResults = dao.countIncludes(definedTerms); - List results = new ArrayList(); + List results = new ArrayList<>(); if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) results = dao.getIncludes(definedTerms, pageSize, pageNumber,propertyPaths); } - return new DefaultPagerImpl(pageNumber, numberOfResults, pageSize, results); + return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results); } @Override public Pager getMedia(DefinedTermBase definedTerm, Integer pageSize, Integer pageNumber) { - Integer numberOfResults = dao.countMedia(definedTerm); + long numberOfResults = dao.countMedia(definedTerm); - List results = new ArrayList(); + List results = new ArrayList<>(); if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) results = dao.getMedia(definedTerm, pageSize, pageNumber); } - return new DefaultPagerImpl(pageNumber, numberOfResults, pageSize, results); + return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results); } @Override public Pager getPartOf(Set definedTerms,Integer pageSize, Integer pageNumber, List propertyPaths) { - Integer numberOfResults = dao.countPartOf(definedTerms); + long numberOfResults = dao.countPartOf(definedTerms); - List results = new ArrayList(); + List results = new ArrayList<>(); if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) results = dao.getPartOf(definedTerms, pageSize, pageNumber, propertyPaths); } - return new DefaultPagerImpl(pageNumber, numberOfResults, pageSize, results); + return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results); } @Override public Pager list(NamedAreaLevel level, NamedAreaType type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { - Integer numberOfResults = dao.count(level, type); + long numberOfResults = dao.count(level, type); - List results = new ArrayList(); + List results = new ArrayList<>(); if (numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) results = dao.list(level, type, pageSize, pageNumber, orderHints, propertyPaths); } - return new DefaultPagerImpl(pageNumber, numberOfResults, pageSize, results); + return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results); } @Override public Pager findByRepresentationText(String label, Class clazz, Integer pageSize, Integer pageNumber) { - Integer numberOfResults = dao.countDefinedTermByRepresentationText(label,clazz); + long numberOfResults = dao.countDefinedTermByRepresentationText(label,clazz); - List results = new ArrayList(); + List results = new ArrayList<>(); if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) results = dao.getDefinedTermByRepresentationText(label, clazz, pageSize, pageNumber); } @@ -216,9 +222,9 @@ public class TermServiceImpl extends IdentifiableServiceBase Pager findByRepresentationAbbreviation(String abbrev, Class clazz, Integer pageSize, Integer pageNumber) { - Integer numberOfResults = dao.countDefinedTermByRepresentationAbbrev(abbrev,clazz); + long numberOfResults = dao.countDefinedTermByRepresentationAbbrev(abbrev,clazz); - List results = new ArrayList(); + List results = new ArrayList<>(); if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize) results = dao.getDefinedTermByRepresentationAbbrev(abbrev, clazz, pageSize, pageNumber); } @@ -270,12 +276,14 @@ public class TermServiceImpl extends IdentifiableServiceBase termsToSave = new HashSet(); DeleteResult result = isDeletable(term.getUuid(), config); + if (result.isAbort()) { + return result; + } //CdmBase.deproxy(dao.merge(term), DefinedTermBase.class); + try { //generalization of Set specificTerms = term.getGeneralizationOf(); @@ -332,62 +340,45 @@ public class TermServiceImpl extends IdentifiableServiceBase includedTerms = term.getIncludes(); if (includedTerms.size()> 0){ -// if (config.isDeleteIncludedTerms()){ -// for (DefinedTermBase includedTerm: includedTerms){ -// config.setCheck(true); -// DeleteResult includedResult = this.delete(includedTerm, config); -//// config.setCheck(isCheck); -// result.includeResult(includedResult); -// } -// }else - if (config.isDeleteIncludedRelations()){ - DefinedTermBase parent = term.getPartOf(); - for (DefinedTermBase includedTerm: includedTerms){ - term.removeIncludes(includedTerm); - if (parent != null){ - parent.addIncludes(includedTerm); - termsToSave.add(parent); - } - } - }else{ - //TODO Exception type - String message = "This term includes other terms. Move or delete included terms prior to delete or change delete configuration."; - result.addRelatedObjects(includedTerms); - result.setAbort(); - Exception ex = new DataChangeNoRollbackException(message); - result.addException(ex); - } + if (config.isDeleteIncludedRelations()){ + DefinedTermBase parent = term.getPartOf(); + for (DefinedTermBase includedTerm: includedTerms){ + term.removeIncludes(includedTerm); + if (parent != null){ + parent.addIncludes(includedTerm); + termsToSave.add(parent); + } + } + }else{ + //TODO Exception type + String message = "This term includes other terms. Move or delete included terms prior to delete or change delete configuration."; + result.addRelatedObjects(includedTerms); + result.setAbort(); + Exception ex = new DataChangeNoRollbackException(message); + result.addException(ex); + } } //part of if (parentTerm != null){ - if (config.isDeletePartOfRelations()){ - parentTerm.removeIncludes(term); - termsToSave.add(parentTerm); - }else{ - //handelede before "included in" - } + if (config.isDeletePartOfRelations()){ + parentTerm.removeIncludes(term); + termsToSave.add(parentTerm); + }else{ + //handled before "included in" + } } -// relatedObjects; - - if (result.isOk()){ TermVocabulary voc = term.getVocabulary(); if (voc!= null){ voc.removeTerm(term); } //TODO save voc - if (true /*!config.isInternal()*/){ + if (true){ dao.delete(term); + result.addDeletedObject(term); dao.saveOrUpdateAll(termsToSave); -// for (DeleteResult.PersistPair persistPair : result.getObjectsToDelete()){ -// persistPair.dao.delete(persistPair.objectToPersist); -// } -// for (DeleteResult.PersistPair persistPair : result.getObjectsToSave()){ -// persistPair.dao.saveOrUpdate(persistPair.objectToPersist); -// } - } } } catch (DataChangeNoRollbackException e) { @@ -405,7 +396,7 @@ public class TermServiceImpl extends IdentifiableServiceBase clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { - //TODO shouldnt this be TermBase instead of DefinedTermBase + //TODO shouldn't this be TermBase instead of DefinedTermBase if (clazz == null){ clazz = DefinedTermBase.class; } @@ -414,27 +405,176 @@ public class TermServiceImpl extends IdentifiableServiceBase references = commonService.getReferencingObjectsForDeletion(term); - if (references != null){ - result.addRelatedObjects(references); - Iterator iterator = references.iterator(); - CdmBase ref; - while (iterator.hasNext()){ - ref = iterator.next(); - if (ref instanceof TermVocabulary){ - result.getRelatedObjects().remove(ref); - }else{ - - String message = "An object of " + ref.getClass().getName() + " with ID " + ref.getId() + " is referencing the object" ; - result.addException(new ReferencedObjectUndeletableException(message)); - result.setAbort(); - } + if(termConfig!=null){ + //generalization of + Set specificTerms = term.getGeneralizationOf(); + if (!specificTerms.isEmpty() && termConfig.isDeleteGeneralizationOfRelations()){ + references.removeAll(specificTerms); + } + //kind of + DefinedTermBase generalTerm = term.getKindOf(); + if (generalTerm != null && termConfig.isDeleteKindOfRelations()){ + references.remove(generalTerm); + } + //part of + DefinedTermBase parentTerm = term.getPartOf(); + if (parentTerm != null && termConfig.isDeletePartOfRelations()){ + references.remove(parentTerm); + } + //included in + Set includedTerms = term.getIncludes(); + if (!includedTerms.isEmpty() && termConfig.isDeleteIncludedRelations()){ + references.removeAll(includedTerms); + } + } + + //gather remaining referenced objects + for (CdmBase relatedObject : references) { + if(relatedObject instanceof TermVocabulary){ + continue; } + result.getRelatedObjects().add(relatedObject); + String message = "An object of " + relatedObject.getClass().getName() + " with ID " + relatedObject.getId() + " is referencing the object" ; + result.addException(new ReferencedObjectUndeletableException(message)); + result.setAbort(); } return result; } + @Override + @Transactional(readOnly = false) + public Map saveOrUpdateRepresentations(Collection representations){ + return representationDao.saveOrUpdateAll(representations); + } + + @Override + @Transactional(readOnly = true) + public List> getUuidAndTitleCache(List vocs, Integer limit, String pattern, Language lang) { + List areas = dao.getUuidAndTitleCache(vocs, limit, pattern); + + List> result = new ArrayList(); + UuidAndTitleCache uuidAndTitleCache; + for (NamedArea area: areas){ + uuidAndTitleCache = new UuidAndTitleCache<>(area.getUuid(), area.getId(), area.labelWithLevel(area, lang)); + result.add(uuidAndTitleCache); + } + + return result; + } + + @Override + public Collection getIncludesAsDto( + TermDto parentTerm) { + return dao.getIncludesAsDto(parentTerm); + } + + @Override + public Collection getKindOfsAsDto( + TermDto parentTerm) { + return dao.getKindOfsAsDto(parentTerm); + } + + @Transactional(readOnly = false) + @Override + public void moveTerm(TermDto termDto, UUID parentUUID) { + moveTerm(termDto, parentUUID, null); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Transactional(readOnly = false) + @Override + public void moveTerm(TermDto termDto, UUID parentUuid, TermMovePosition termMovePosition) { + boolean isKindOf = termDto.getKindOfUuid()!=null && termDto.getKindOfUuid().equals(parentUuid); + TermVocabulary vocabulary = HibernateProxyHelper.deproxy(vocabularyService.load(termDto.getVocabularyUuid())); + DefinedTermBase parent = HibernateProxyHelper.deproxy(dao.load(parentUuid)); + if(parent==null){ + //new parent is a vocabulary + TermVocabulary parentVocabulary = HibernateProxyHelper.deproxy(vocabularyService.load(parentUuid)); + DefinedTermBase term = HibernateProxyHelper.deproxy(dao.load(termDto.getUuid())); + if(parentVocabulary!=null){ + term.setKindOf(null); + term.setPartOf(null); + + vocabulary.removeTerm(term); + parentVocabulary.addTerm(term); + } + vocabularyService.saveOrUpdate(parentVocabulary); + } + else { + DefinedTermBase term = HibernateProxyHelper.deproxy(dao.load(termDto.getUuid())); + //new parent is a term + if(parent.isInstanceOf(OrderedTermBase.class) + && term.isInstanceOf(OrderedTermBase.class) + && termMovePosition!=null + && HibernateProxyHelper.deproxy(parent, OrderedTermBase.class).getVocabulary().isInstanceOf(OrderedTermVocabulary.class)) { + //new parent is an ordered term + OrderedTermBase orderedTerm = HibernateProxyHelper.deproxy(term, OrderedTermBase.class); + OrderedTermBase targetOrderedDefinedTerm = HibernateProxyHelper.deproxy(parent, OrderedTermBase.class); + OrderedTermVocabulary otVoc = HibernateProxyHelper.deproxy(targetOrderedDefinedTerm.getVocabulary(), OrderedTermVocabulary.class); + if(termMovePosition.equals(TermMovePosition.BEFORE)) { + orderedTerm.getVocabulary().removeTerm(orderedTerm); + otVoc.addTermAbove(orderedTerm, targetOrderedDefinedTerm); + if (targetOrderedDefinedTerm.getPartOf() != null){ + targetOrderedDefinedTerm.getPartOf().addIncludes(orderedTerm); + } + } + else if(termMovePosition.equals(TermMovePosition.AFTER)) { + orderedTerm.getVocabulary().removeTerm(orderedTerm); + otVoc.addTermBelow(orderedTerm, targetOrderedDefinedTerm); + if (targetOrderedDefinedTerm.getPartOf() != null){ + targetOrderedDefinedTerm.getPartOf().addIncludes(orderedTerm); + } + } + else if(termMovePosition.equals(TermMovePosition.ON)) { + orderedTerm.getVocabulary().removeTerm(orderedTerm); + targetOrderedDefinedTerm.addIncludes(orderedTerm); + targetOrderedDefinedTerm.getVocabulary().addTerm(orderedTerm); + } + } + else{ + vocabulary.removeTerm(term); + if(isKindOf){ + parent.addGeneralizationOf(term); + } + else{ + parent.addIncludes(term); + } + parent.getVocabulary().addTerm(term); + } + vocabularyService.saveOrUpdate(parent.getVocabulary()); + } + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + @Transactional(readOnly = false) + @Override + public TermDto addNewTerm(TermType termType, UUID parentUUID, boolean isKindOf) { + DefinedTermBase term = termType.getEmptyDefinedTermBase(); + dao.save(term); + DefinedTermBase parent = dao.load(parentUUID); + if(isKindOf){ + parent.addGeneralizationOf(term); + } + else{ + parent.addIncludes(term); + } + parent.getVocabulary().addTerm(term); + dao.saveOrUpdate(parent); + return TermDto.fromTerm(term, true); + } + + public enum TermMovePosition{ + BEFORE, + AFTER, + ON + } + }