import eu.etaxonomy.cdm.api.service.pager.Pager;
import eu.etaxonomy.cdm.api.service.pager.PagerUtils;
import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
+import eu.etaxonomy.cdm.hibernate.HHH_9751_Util;
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
+import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
+import eu.etaxonomy.cdm.model.common.CdmBase;
+import eu.etaxonomy.cdm.model.common.DefinedTerm;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
import eu.etaxonomy.cdm.model.reference.Reference;
import eu.etaxonomy.cdm.model.taxon.Classification;
+import eu.etaxonomy.cdm.model.taxon.HomotypicGroupTaxonComparator;
import eu.etaxonomy.cdm.model.taxon.Synonym;
import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
import eu.etaxonomy.cdm.model.taxon.Taxon;
-import eu.etaxonomy.cdm.model.taxon.TaxonNaturalComparator;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNodeAgentRelation;
-import eu.etaxonomy.cdm.model.taxon.TaxonNodeByNameComparator;
-import eu.etaxonomy.cdm.model.taxon.TaxonNodeByRankAndNameComparator;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
-import eu.etaxonomy.cdm.persistence.dao.common.IDefinedTermDao;
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;
import eu.etaxonomy.cdm.persistence.dao.taxon.ITaxonNodeDao;
+import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;
/**
* @author n.hoffmann
@Autowired
private IBeanInitializer defaultBeanInitializer;
- private final Comparator<? super TaxonNode> taxonNodeComparator = new TaxonNodeByNameComparator();
-
@Autowired
private ITaxonService taxonService;
@Autowired
- private IClassificationService classService;
-
- @Autowired
- private IDefinedTermDao termDao;
+ private IAgentService agentService;
@Override
public List<TaxonNode> loadChildNodesOfTaxonNode(TaxonNode taxonNode,
List<String> propertyPaths, boolean recursive, NodeSortMode sortMode) {
- taxonNode = dao.load(taxonNode.getUuid());
+
+ getSession().refresh(taxonNode);
List<TaxonNode> childNodes;
if (recursive == true){
childNodes = dao.listChildrenOf(taxonNode, null, null, null, recursive);
}else{
childNodes = new ArrayList<TaxonNode>(taxonNode.getChildNodes());
}
+
+ HHH_9751_Util.removeAllNull(childNodes);
+
if (sortMode != null){
- Comparator<TaxonNode> comparator = null;
- if (sortMode.equals(NodeSortMode.NaturalOrder)){
- comparator = new TaxonNaturalComparator();
- } else if (sortMode.equals(NodeSortMode.AlphabeticalOrder)){
- comparator = new TaxonNodeByNameComparator();
- } else if (sortMode.equals(NodeSortMode.RankAndAlphabeticalOrder)){
- comparator = new TaxonNodeByRankAndNameComparator();
- }
+ Comparator<TaxonNode> comparator = sortMode.newComparator();
Collections.sort(childNodes, comparator);
}
defaultBeanInitializer.initializeAll(childNodes, propertyPaths);
return childNodes;
}
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public Pager<TaxonNodeDto> pageChildNodesDTOs(UUID taxonNodeUuid, boolean recursive,
+ boolean doSynonyms, NodeSortMode sortMode,
+ Integer pageSize, Integer pageIndex) {
+
+ TaxonNode parentNode = dao.load(taxonNodeUuid);
+
+ List<CdmBase> allRecords = new ArrayList<>();
+
+ //acceptedTaxa
+ List<TaxonNode> childNodes = loadChildNodesOfTaxonNode(parentNode, null, recursive, sortMode);
+ allRecords.addAll(childNodes);
+
+ //add synonyms if pager is not yet full synonyms
+ List<Synonym> synList = new ArrayList<>(parentNode.getTaxon().getSynonyms());
+ Collections.sort(synList, new HomotypicGroupTaxonComparator(null));
+ //TODO: test sorting
+
+ allRecords.addAll(synList);
+
+
+ List<TaxonNodeDto> dtos = new ArrayList<>(pageSize);
+ int start = PagerUtils.startFor(pageSize, pageIndex);
+ int limit = PagerUtils.limitFor(pageSize);
+ Long totalCount = Long.valueOf(allRecords.size());
+
+ if(PagerUtils.hasResultsInRange(totalCount, pageIndex, pageSize)) {
+ TaxonNameBase<?,?> parentName = null;
+
+ for(int i = start; i < Math.min(totalCount, start + limit); i++) {
+ CdmBase record = allRecords.get(i);
+
+ if (record.isInstanceOf(TaxonNode.class)){
+ dtos.add(new TaxonNodeDto(CdmBase.deproxy(record, TaxonNode.class)));
+ }else if (record.isInstanceOf(Synonym.class)){
+ Synonym synonym = CdmBase.deproxy(record, Synonym.class);
+ parentName = parentName == null? parentNode.getTaxon().getName(): parentName;
+ boolean isHomotypic = synonym.getName().isHomotypic(parentName);
+ dtos.add(new TaxonNodeDto(synonym, isHomotypic));
+ }
+ }
+ }
+
+ return new DefaultPagerImpl<TaxonNodeDto>(pageIndex, totalCount, pageSize , dtos);
+ }
+
+ @Override
+ public TaxonNodeDto parentDto(UUID taxonNodeUuid) {
+ TaxonNode taxonNode = dao.load(taxonNodeUuid);
+ if(taxonNode.getParent() != null) {
+ return new TaxonNodeDto(taxonNode.getParent());
+ }
+ return null;
+ }
+
@Override
@Autowired
protected void setDao(ITaxonNodeDao dao) {
@Override
@Transactional
- public UpdateResult moveTaxonNode(UUID taxonNodeUuid, UUID targetNodeUuid, boolean isParent){
- TaxonNode taxonNode = dao.load(taxonNodeUuid);
- TaxonNode targetNode = dao.load(targetNodeUuid);
- return moveTaxonNode(taxonNode, targetNode, isParent);
+ public UpdateResult moveTaxonNode(UUID taxonNodeUuid, UUID targetNodeUuid, int movingType){
+ TaxonNode taxonNode = HibernateProxyHelper.deproxy(dao.load(taxonNodeUuid), TaxonNode.class);
+ TaxonNode targetNode = HibernateProxyHelper.deproxy(dao.load(targetNodeUuid), TaxonNode.class);
+ return moveTaxonNode(taxonNode, targetNode, movingType);
}
@Override
@Transactional
- public UpdateResult moveTaxonNode(TaxonNode taxonNode, TaxonNode newParent, boolean isParent){
+ public UpdateResult moveTaxonNode(TaxonNode taxonNode, TaxonNode newParent, int movingType){
UpdateResult result = new UpdateResult();
- Integer sortIndex;
- if (isParent){
+ TaxonNode parentParent = HibernateProxyHelper.deproxy(newParent.getParent(), TaxonNode.class);
- sortIndex = newParent.getChildNodes().size();
- }else{
+ Integer sortIndex = -1;
+ if (movingType == 0){
+ sortIndex = 0;
+ }else if (movingType == 1){
+ sortIndex = newParent.getSortIndex();
+ newParent = parentParent;
+ } else if (movingType == 2){
sortIndex = newParent.getSortIndex() +1;
- newParent = newParent.getParent();
+ newParent = parentParent;
+ } else{
+ result.setAbort();
+ result.addException(new Exception("The moving type "+ movingType +" is not supported."));
}
result.addUpdatedObject(newParent);
result.addUpdatedObject(taxonNode.getParent());
result.setCdmEntity(taxonNode);
+
newParent.addChildNode(taxonNode, sortIndex, taxonNode.getReference(), taxonNode.getMicroReference());
+
dao.saveOrUpdate(newParent);
return result;
@Override
@Transactional
- public UpdateResult moveTaxonNodes(Set<UUID> taxonNodeUuids, UUID newParentNodeUuid, boolean isParent){
+ public UpdateResult moveTaxonNodes(Set<UUID> taxonNodeUuids, UUID newParentNodeUuid, int movingType){
UpdateResult result = new UpdateResult();
TaxonNode targetNode = dao.load(newParentNodeUuid);
for (UUID taxonNodeUuid: taxonNodeUuids){
TaxonNode taxonNode = dao.load(taxonNodeUuid);
- result.includeResult(moveTaxonNode(taxonNode,targetNode, isParent));
+ result.includeResult(moveTaxonNode(taxonNode,targetNode, movingType));
}
return result;
}
@Transactional
public UpdateResult createNewTaxonNode(UUID parentNodeUuid, Taxon newTaxon, Reference ref, String microref){
UpdateResult result = new UpdateResult();
+
+ UUID taxonUUID = taxonService.saveOrUpdate(newTaxon);
+ newTaxon = (Taxon) taxonService.load(taxonUUID);
+
TaxonNode parent = dao.load(parentNodeUuid);
TaxonNode child = null;
try{
child = parent.addChildTaxon(newTaxon, parent.getReference(), parent.getMicroReference());
}catch(Exception e){
- logger.error("TaxonNode could not be created. "+ e.getLocalizedMessage());
result.addException(e);
+ result.setError();
+ return result;
}
// child = dao.save(child);
dao.saveOrUpdate(parent);
result.addUpdatedObject(parent);
- result.setCdmEntity(child);
+ if (child != null){
+ result.setCdmEntity(child);
+ }
return result;
}
+ @Override
+ @Transactional
+ public UpdateResult createNewTaxonNode(UUID parentNodeUuid, UUID taxonUuid, Reference ref, String microref){
+ UpdateResult result = new UpdateResult();
+ TaxonNode parent = dao.load(parentNodeUuid);
+ Taxon taxon = (Taxon) taxonService.load(taxonUuid);
+ TaxonNode child = null;
+ try{
+ child = parent.addChildTaxon(taxon, parent.getReference(), parent.getMicroReference());
+ }catch(Exception e){
+ result.addException(e);
+ result.setError();
+ return result;
+ }
+// child = dao.save(child);
+
+ dao.saveOrUpdate(parent);
+ result.addUpdatedObject(parent);
+ if (child != null){
+ result.setCdmEntity(child);
+ }
+ return result;
+
+ }
+
+ @Override
+ @Transactional
+ public UpdateResult addTaxonNodeAgentRelation(UUID taxonNodeUUID, UUID agentUUID, DefinedTerm relationshipType){
+ UpdateResult result = new UpdateResult();
+ TaxonNode node = dao.load(taxonNodeUUID);
+ TeamOrPersonBase agent = (TeamOrPersonBase) agentService.load(agentUUID);
+ node.addAgentRelation(relationshipType, agent);
+ try{
+ dao.merge(node, true);
+ }catch (Exception e){
+ result.setError();
+ result.addException(e);
+ }
+ result.setCdmEntity(node);
+ return result;
+ }
+
}
BGBM BDI Projects / cdmlib.git / blobdiff