X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/24f1c3c4034e0a1845940e0b40955f003d329335..50355d238b6a375caf844d5ede15a388690fe6f2:/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonNodeServiceImpl.java

diff --git a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonNodeServiceImpl.java b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonNodeServiceImpl.java
index 4113330654..68318b3534 100644
--- a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonNodeServiceImpl.java
+++ b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/TaxonNodeServiceImpl.java
@@ -32,25 +32,27 @@ import eu.etaxonomy.cdm.api.service.dto.CdmEntityIdentifier;
 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
@@ -65,42 +67,92 @@ public class TaxonNodeServiceImpl extends AnnotatableServiceBase<TaxonNode, ITax
     @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) {
@@ -523,29 +575,38 @@ public class TaxonNodeServiceImpl extends AnnotatableServiceBase<TaxonNode, ITax
 
     @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;
@@ -555,12 +616,12 @@ public class TaxonNodeServiceImpl extends AnnotatableServiceBase<TaxonNode, ITax
 
     @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;
     }
@@ -586,21 +647,70 @@ public class TaxonNodeServiceImpl extends AnnotatableServiceBase<TaxonNode, ITax
     @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;
+    }
+
 
 }