EDIT

import eu.etaxonomy.cdm.api.service.config.SubtreeCloneConfigurator;

    public List<TaxonDistributionDTO> getTaxonDistributionDTO(List<UUID> nodeUuids, List<String> propertyPaths, boolean openChildren);

     * Clones a subtree including all taxa and taxon nodes.

     * @param config the configurator for the cloning

    public UpdateResult cloneSubtree(SubtreeCloneConfigurator config);

import eu.etaxonomy.cdm.api.service.config.SubtreeCloneConfigurator;

import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;

import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;

    @Autowired

    private IReferenceDao referenceDao;

    @Autowired

    private IClassificationDao classificationDao;

    @Override

    @Transactional(readOnly = false)

    public UpdateResult cloneSubtree(SubtreeCloneConfigurator config) {

        UpdateResult result = new UpdateResult();

        if (config.getSubTreeUuids().isEmpty()){

            return result;

        }

        //TODO error handling

        Reference taxonSecundum = config.isReuseTaxa() || config.isReuseTaxonSecundum() || config.getTaxonSecundumUuid() == null ?

                null : referenceDao.findByUuid(config.getTaxonSecundumUuid());

        config.setTaxonSecundum(taxonSecundum);

        Reference parentChildReference = config.isReuseParentChildReference() || config.getParentChildReferenceUuid() == null ?

                null : referenceDao.findByUuid(config.getParentChildReferenceUuid());

        config.setParentChildReference(parentChildReference);

        Reference taxonRelationshipReference = config.getRelationTypeToOldTaxon() == null ?

                null : referenceDao.findByUuid(config.getRelationshipReferenceUuid());

        config.setRelationshipReference(taxonRelationshipReference);

        Classification classificationClone = Classification.NewInstance(config.getClassificationName());

        if (config.isReuseClassificationReference()){

            TaxonNode anyNode = dao.findByUuid(config.getSubTreeUuids().iterator().next());

            if (anyNode != null){

                Reference oldClassificationRef = anyNode.getClassification().getReference();

                classificationClone.setReference(oldClassificationRef);

            }

        }else if (config.getClassificationReferenceUuid() != null) {

            Reference classificationReference = referenceDao.findByUuid(config.getClassificationReferenceUuid());

            classificationClone.setReference(classificationReference);

        }

        //clone taxa and taxon nodes

//      List<Integer> childNodeIds = taxonNodeService.idList(taxonNodeFilter);

//      List<TaxonNode> childNodes = taxonNodeService.loadByIds(childNodeIds, null);

        List<TaxonNode> rootNodes = this.find(config.getSubTreeUuids());

        for (TaxonNode taxonNode : rootNodes) {

            addChildTaxaToClone(taxonNode, classificationClone.getRootNode(), config);

        }

        classificationDao.saveOrUpdate(classificationClone);

        result.setCdmEntity(classificationClone);

        return result;

    }

    private void addChildTaxaToClone(TaxonNode originalParentNode, TaxonNode parentNodeClone,

            SubtreeCloneConfigurator config){

        Taxon originalTaxon = CdmBase.deproxy(originalParentNode.getTaxon());

        if (originalTaxon == null){

            for (TaxonNode originalChildChildNode : originalParentNode.getChildNodes()) {

                addChildTaxaToClone(originalChildChildNode, parentNodeClone, config);

            }

        }else{

            TaxonNode childNodeClone;

            String microReference = null;

            if (config.isReuseTaxa()){

                childNodeClone = parentNodeClone.addChildTaxon(originalTaxon, config.getParentChildReference(), microReference);

            }else{

                Taxon cloneTaxon = originalTaxon.clone(config.isIncludeSynonymsIncludingManAndProParte(),

                        config.isIncludeTaxonRelationshipsExcludingManAndProParte(),

                        config.isIncludeDescriptiveData(), config.isIncludeMedia());

                //name

                if (!config.isReuseNames()){

                    cloneTaxon.setName(cloneTaxon.getName().clone());

                    //TODO needs further handling for name relationships etc., see #9349

                    cloneTaxon.getSynonyms().forEach(syn ->

                        syn.setName(syn.getName() == null ? null : syn.getName().clone()));

                }

                if (!config.isReuseTaxonSecundum()){

                    cloneTaxon.setSec(config.getTaxonSecundum());

                }

                //add relation between taxa

                if (config.getRelationTypeToOldTaxon() != null){

                    TaxonRelationship rel = cloneTaxon.addTaxonRelation(originalParentNode.getTaxon(), config.getRelationTypeToOldTaxon(),

                            config.getRelationshipReference(), microReference);

                    rel.setDoubtful(config.isRelationDoubtful());

                }

                childNodeClone = parentNodeClone.addChildTaxon(cloneTaxon, config.getParentChildReference(), microReference);

            }

            //probably necessary as taxon nodes do not cascade

            dao.saveOrUpdate(childNodeClone);

            //add children

            List<TaxonNode> originalChildNodes = originalParentNode.getChildNodes();

            HHH_9751_Util.removeAllNull(originalChildNodes);

            for (TaxonNode originalChildNode : originalChildNodes) {

                addChildTaxaToClone(originalChildNode, childNodeClone, config);

            }

        }

    }

    public static final UUID CLASSIFICATION_UUID = UUID.fromString("6c2bc8d9-ee62-4222-be89-4a8e31770878");

import java.util.stream.Collectors;

import eu.etaxonomy.cdm.api.service.config.SubtreeCloneConfigurator;

import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;

import eu.etaxonomy.cdm.persistence.dao.reference.IReferenceDao;

import eu.etaxonomy.cdm.persistence.dao.taxon.IClassificationDao;

    @SpringBeanByType

    private IClassificationDao classificationDao;

    @SpringBeanByType

    private IReferenceDao referenceDao;

    @Test

    @DataSet("ClassificationServiceImplTest.xml")

    public final void testCloneClassification(){

        Classification originalClassification = classificationDao.load(ClassificationServiceImplTest.CLASSIFICATION_UUID);

        SubtreeCloneConfigurator config = SubtreeCloneConfigurator.NewBaseInstance(

                originalClassification.getRootNode().getUuid(), "Cloned classification");

        Classification classificatonClone = (Classification) taxonNodeService.cloneSubtree(config).getCdmEntity();

        assertEquals("# of direct children does not match", originalClassification.getChildNodes().size(), classificatonClone.getChildNodes().size());

        assertEquals("# of all nodes does not match", originalClassification.getAllNodes().size(), classificatonClone.getAllNodes().size());

        Set<UUID> originalTaxonSecUuids = originalClassification.getAllNodes().stream().map(tn -> tn.getTaxon().getSec().getUuid()).collect(Collectors.toSet());

        for (TaxonNode clonedTaxonNode : classificatonClone.getChildNodes()) {

            //test no reuse of taxon

            Taxon clonedTaxon = clonedTaxonNode.getTaxon();

            TaxonNode originalNode = originalClassification.getNode(clonedTaxon);

            assertNull(originalNode);

            //check relationship

            assertEquals(0, clonedTaxon.getRelationsFromThisTaxon().size());

            //test taxon sec

            assertTrue(originalTaxonSecUuids.contains(clonedTaxon.getSec().getUuid()));

        }

        commitAndStartNewTransaction();

        //test reuse taxon

        config.setReuseTaxa(true);

        classificatonClone = (Classification) taxonNodeService.cloneSubtree(config).getCdmEntity();

        assertEquals("# of direct children does not match", originalClassification.getChildNodes().size(), classificatonClone.getChildNodes().size());

        originalTaxonSecUuids = originalClassification.getAllNodes().stream().map(tn -> tn.getTaxon().getSec().getUuid()).collect(Collectors.toSet());

        for (TaxonNode taxonNode : classificatonClone.getChildNodes()) {

            //test no reuse of taxon

            Taxon clonedTaxon = taxonNode.getTaxon();

            TaxonNode originalNode = originalClassification.getNode(clonedTaxon);

            assertNotNull(originalNode);

            Taxon originalTaxon = originalNode.getTaxon();

            assertNotNull(originalTaxon);

            //check relationship

            assertEquals(0, clonedTaxon.getRelationsFromThisTaxon().size());

            //test taxon sec

            assertEquals(originalTaxon.getSec().getUuid(), clonedTaxon.getSec().getUuid());

        }

        commitAndStartNewTransaction();

        config.setReuseTaxa(false);  //reset

        config.setRelationTypeToOldTaxon(TaxonRelationshipType.CONGRUENT_TO());

        Reference sec = referenceDao.findByUuid(UUID.fromString("719d136b-409e-40d0-9561-46f6999465b4"));

        config.setTaxonSecundumUuid(sec.getUuid());

        classificatonClone = (Classification) taxonNodeService.cloneSubtree(config).getCdmEntity();

        originalTaxonSecUuids = originalClassification.getAllNodes().stream().map(tn -> tn.getTaxon().getSec().getUuid()).collect(Collectors.toSet());

        for (TaxonNode taxonNode : classificatonClone.getChildNodes()) {

            //test no reuse of taxon

            Taxon clonedTaxon = taxonNode.getTaxon();

            TaxonNode originalNode = originalClassification.getNode(clonedTaxon);

            assertNull(originalNode);

            //check relationship

            TaxonRelationship relShip = clonedTaxon.getRelationsFromThisTaxon().iterator().next();

            Taxon relatedTaxon = relShip.getToTaxon();

            Taxon relatedOriginalTaxon = originalClassification.getNode(relatedTaxon).getTaxon();

            assertEquals(relatedOriginalTaxon.getName(), clonedTaxon.getName());

            assertTrue(relShip.getType().equals(TaxonRelationshipType.CONGRUENT_TO()));

            //test taxon sec

            assertEquals(relatedOriginalTaxon.getSec().getUuid(), clonedTaxon.getSec().getUuid());

        }

        commitAndStartNewTransaction();

    }