EDIT

package eu.etaxonomy.cdm.remote.controller;

import java.io.IOException;

import java.util.Arrays;

import java.util.List;

import java.util.UUID;

import eu.etaxonomy.cdm.api.service.IClassificationService;

import eu.etaxonomy.cdm.api.service.ITaxonService;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.model.common.DefinedTermBase;

import eu.etaxonomy.cdm.model.name.Rank;

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

            HttpServletResponse response) {

        logger.info("getPathFromTaxonToRank() " + request.getRequestURI());

        Classification tree = service.find(treeUuid);

        Rank rank = findRank(rankUuid);

        Taxon taxon = (Taxon) taxonService.load(taxonUuid);

    }

    /**

import eu.etaxonomy.cdm.api.service.search.DocumentSearchResult;

import eu.etaxonomy.cdm.api.service.search.LuceneParseException;

import eu.etaxonomy.cdm.common.DocUtils;

import eu.etaxonomy.cdm.hibernate.search.AcceptedTaxonBridge;

import eu.etaxonomy.cdm.io.dwca.in.DwcaImportTransformer;

import eu.etaxonomy.cdm.model.common.CdmBase;

            @RequestParam(value = "classification", required = false, defaultValue = CLASSIFICATION_DEFAULT) String classificationType,

            @RequestParam(value = "include", required = false, defaultValue = "") String[] includes,

            HttpServletRequest request, HttpServletResponse response) throws IOException {

        ModelAndView mv = new ModelAndView();

        List<RemoteResponse> tiList = new ArrayList<>();

        // loop through each name uuid

                    Taxon taxon = (Taxon) tb;

                    // build classification map

                    boolean includeUuids = Arrays.asList(includes).contains(INCLUDE_CLUUIDS);

                    logger.info("taxon uuid " + taxon.getUuid().toString() + " original hash code : " + System.identityHashCode(taxon) + ", name class " + taxon.getName().getClass().getName());

                    // update taxon information object with taxon related data

        List<RemoteResponse> ansList = new ArrayList<RemoteResponse>();

        logger.info("doGetAcceptedNameSearch()");

        // if search type is not known then return error

        if (!searchType.equals(NAME_SEARCH) && !searchType.equals(TITLE_SEARCH)) {

            ErrorResponse er = new ErrorResponse();

                            Taxon accTaxon = synonym.getAcceptedTaxon();

                            if (accTaxon != null) {

                                INonViralName accNvn = CdmBase.deproxy(accTaxon.getName());

                                ans.addToResponseList(accNvn.getNameCache(),accNvn.getAuthorshipCache(), accNvn.getRank().getTitleCache(), classificationMap);

                            }

                        } else {

                                }

                            }

                            if(isConceptRelationship) {

                                ans.addToResponseList(nvn.getNameCache(), nvn.getAuthorshipCache(),nvn.getRank().getTitleCache(), classificationMap);

                            }

    /**

     * Build classification map.

     */

        // Using TreeMap is important, because we need the sorting of the classification keys

        // in the map to be stable.

        // if classification key is 'default' then return the default element of the map

        if(classificationType.equals(CLASSIFICATION_DEFAULT) && !sourceClassificationMap.isEmpty()) {

        } else if(classificationType.equals(CLASSIFICATION_ALL)) {

            return sourceClassificationMap;

        } else {

        }

    }

    /**

     * Build classification map.

     */

        // Using TreeMap is important, because we need the sorting of the classification keys

        // in the map to be stable.

        Set<TaxonNode> taxonNodes = taxon.getTaxonNodes();

        //loop through taxon nodes and build classification map for each classification key

        for (TaxonNode tn : taxonNodes) {

                }

            }

            String cname = removeInternalWhitespace(tn.getClassification().getTitleCache());

            logger.info("Building classification map " + cname);

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.hibernate.HHH_9751_Util;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.common.CdmBase;

    }

    /**

     */

    @Override

        TaxonNode thisNode = taxonNodeDao.load(taxonNode.getUuid(), propertyPaths);

        if(baseRank != null){

            baseRank = (Rank) termDao.load(baseRank.getUuid());

        }

        pathToRoot.add(thisNode);

        while(!thisNode.isTopmostNode()){

            //TODO why do we need to deproxy here?

            //     without this thisNode.getParent() will return NULL in

            //     some cases (environment dependend?) even if the parent exits

            if(parentNode == null){

            }

            if(parentNode.getTaxon() == null){

            }

            if(parentNode.getTaxon().getName() == null){

                throw new NullPointerException("The name of the taxon associated with taxonNode " + parentNode + " is NULL");

            }

            // stop if the next parent is higher than the baseRank

            if(baseRank != null && parentNodeRank != null && baseRank.isLower(parentNodeRank)){

                break;

    }

    @Override

        if(node == null){

            logger.warn("The specified taxon is not found in the given tree.");

            return null;

        }

    }

import eu.etaxonomy.cdm.api.service.dto.GroupedTaxonDTO;

import eu.etaxonomy.cdm.api.service.dto.TaxonInContextDTO;

import eu.etaxonomy.cdm.api.service.pager.Pager;

import eu.etaxonomy.cdm.model.common.MarkerType;

import eu.etaxonomy.cdm.model.media.MediaRepresentation;

import eu.etaxonomy.cdm.model.name.Rank;

     * @param propertyPaths

     *            the initialization strategy for the returned TaxonNode

     *            instances.

     * @return the path of nodes from the <b>base node</b> to the node of the

     */

    /**

     * Although this method seems to be a redundant alternative to {@link #loadChildNodesOfTaxonNode(TaxonNode, List)} it is an important

     *            Nodes of this rank or in case this rank does not exist in the

     *            current branch the next lower rank is taken as as root node for

     *            this rank henceforth called the <b>base node</b>.

     * @param propertyPaths

     *            the initialization strategy for the returned TaxonNode

     *            instances.

     * @return the path of nodes from the <b>base node</b> to the node of the specified

     */

    public List<TaxonNode> listChildNodesOfTaxon(UUID taxonUuid, UUID classificationUuid, boolean includeUnpublished,

            Integer pageSize, Integer pageIndex, List<String> propertyPaths);