EDIT

    public static TaxonNodeFilter NewRankInstance(UUID rankMinUuid, UUID rankMaxUuid){

        return new TaxonNodeFilter().setRankMin(rankMinUuid).setRankMax(rankMaxUuid);

    }

        resetSubtrees();

    private void resetSubtrees() {

        subtrees = new ArrayList<>();

    }

import org.hibernate.LazyInitializationException;

	    try{

	        for (int i = 0; i < children.size(); i++) {

	            children.get(i).setSortIndex(i);

	        }

	    } catch (LazyInitializationException e) {

            logger.info("Cannot clean up uninitialized children without a session, skipping.");

import eu.etaxonomy.cdm.persistence.dto.DescriptiveDataSetBaseDto;

    /**

     * @param uuid

     * @return

     */

    DescriptiveDataSetBaseDto getDescriptiveDataSetDtoByUuid(UUID uuid);

import org.springframework.beans.factory.annotation.Autowired;

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

import eu.etaxonomy.cdm.persistence.dao.term.IDefinedTermDao;

import eu.etaxonomy.cdm.persistence.dao.term.ITermTreeDao;

import eu.etaxonomy.cdm.persistence.dto.DescriptiveDataSetBaseDto;

import eu.etaxonomy.cdm.persistence.dto.TaxonNodeDto;

import eu.etaxonomy.cdm.persistence.dto.TermDto;

import eu.etaxonomy.cdm.persistence.dto.TermTreeDto;

	 @Autowired

	 private ITermTreeDao termTreeDao;

	 @Autowired

     private IDefinedTermDao termDao;

	 @Autowired

     private ITaxonNodeDao nodeDao;

    private List<UUID> getNodeUuidsForDescriptiveDataSet(UUID uuid) {

        Session session = getSession();

        String queryString = "SELECT t.uuid  FROM DescriptiveDataSet a JOIN a.taxonSubtreeFilter as t WHERE a.uuid = :uuid";

        Query query;

        query = session.createQuery(queryString);

        query.setParameter("uuid", uuid);

        @SuppressWarnings("unchecked")

        List<UUID> result = query.list();

        List<UUID> list = new ArrayList<>();

        for(UUID object : result){

            list.add(object);

        }

        return list;

    }

    @Override

    public DescriptiveDataSetBaseDto getDescriptiveDataSetDtoByUuid(UUID uuid) {

        String queryString = DescriptiveDataSetBaseDto.getDescriptiveDataSetDtoSelect()

                + " WHERE a.uuid = :uuid"

                + " ORDER BY a.titleCache";

        Query query =  getSession().createQuery(queryString);

        query.setParameter("uuid", uuid);

        @SuppressWarnings("unchecked")

        List<Object[]> result = query.list();

        List<DescriptiveDataSetBaseDto> list = DescriptiveDataSetBaseDto.descriptiveDataSetBaseDtoListFrom(result);

        UUID descriptiveSystemUuid = null;

        UUID minRankUuid = null;

        UUID maxRankUuid = null;

        if (result != null && !result.isEmpty()){

            Object[] descriptiveDataSetResult = result.get(0);

            descriptiveSystemUuid = (UUID)descriptiveDataSetResult[4];

            minRankUuid = (UUID)descriptiveDataSetResult[5];

            maxRankUuid = (UUID)descriptiveDataSetResult[6];

        }else{

            return null;

        }

        //get descriptiveSystem

        DescriptiveDataSetBaseDto dto = list.get(0);

        if (descriptiveSystemUuid != null){

            TermTreeDto treeDto = termTreeDao.getTermTreeDtosByUuid(descriptiveSystemUuid);

            dto.setDescriptiveSystem(treeDto);

        }

        //get taxon nodes

        List<UUID> nodeUuids = getNodeUuidsForDescriptiveDataSet(uuid);

        List<TaxonNodeDto> nodeDtos = nodeDao.getTaxonNodeDtos(nodeUuids);

        Set<TaxonNodeDto> nodeSet = new HashSet<>(nodeDtos);

        dto.setSubTreeFilter(nodeSet);

        TermDto minRank = termDao.getTermDto(minRankUuid);

        TermDto maxRank = termDao.getTermDto(maxRankUuid);

        dto.setMaxRank(maxRank);

        dto.setMinRank(minRank);

        return dto;

    }

    @Override

    public TaxonNodeDto getTaxonNodeDto(UUID nodeUuid) {

        String queryString = "SELECT new " + SortableTaxonNodeQueryResult.class.getName() + "("

                + "tn.uuid, tn.id, t.titleCache, rank "

                + ") "

                + " FROM TaxonNode tn "

                + "   INNER JOIN tn.taxon AS t "

                + "   INNER JOIN t.name AS name "

                + "   LEFT OUTER JOIN name.rank AS rank "

                + " WHERE t.uuid LIKE :uuid ";

        Query query =  getSession().createQuery(queryString);

        query.setParameter("uuid", nodeUuid.toString());

        @SuppressWarnings("unchecked")

        List<SortableTaxonNodeQueryResult> result = query.list();

        Collections.sort(result, new SortableTaxonNodeQueryResultComparator());

        List<TaxonNodeDto> list = new ArrayList<>();

        for(SortableTaxonNodeQueryResult queryDTO : result){

            list.add(new TaxonNodeDto(queryDTO.getTaxonNodeUuid(), queryDTO.getTaxonNodeId(), queryDTO.getTaxonTitleCache()));

        }

        return list.get(0);

    }

    @Override

    public List<TaxonNodeDto> getTaxonNodeDtos(List<UUID> nodeUuids) {

        String queryString = "SELECT new " + SortableTaxonNodeQueryResult.class.getName() + "("

                + "tn.uuid, tn.id, t.titleCache, rank "

                + ") "

                + " FROM TaxonNode tn "

                + "   INNER JOIN tn.taxon AS t "

                + "   INNER JOIN t.name AS name "

                + "   LEFT OUTER JOIN name.rank AS rank "

                + " WHERE t.uuid IN (:uuid) ";

        Query query =  getSession().createQuery(queryString);

//        List<String> uuidStrings = nodeUuids.stream().map(e -> e.toString()).collect(Collectors.toList());

        query.setParameterList("uuid", nodeUuids);

        @SuppressWarnings("unchecked")

        List<SortableTaxonNodeQueryResult> result = query.list();

        Collections.sort(result, new SortableTaxonNodeQueryResultComparator());

        List<TaxonNodeDto> list = new ArrayList<>();

        for(SortableTaxonNodeQueryResult queryDTO : result){

            TaxonNodeDto nodeDto = new TaxonNodeDto(queryDTO.getTaxonNodeUuid(), queryDTO.getTaxonNodeId(), queryDTO.getTaxonTitleCache(), queryDTO.getNameRank().getOrderIndex());

            list.add(nodeDto);

        }

        return list;

    }

    @Override

    public List<TaxonNodeDto> getTaxonNodeForTaxonInClassificationDto(UUID taxonUUID, UUID classificationUuid) {

        String queryString = "SELECT new " + SortableTaxonNodeQueryResult.class.getName() + "("

                + "tn.uuid, tn.id, t.titleCache, rank "

                + ") "

                + " FROM TaxonNode tn "

                + "   INNER JOIN tn.taxon AS t "

                + "   INNER JOIN tn.classification AS cls "

                + "   INNER JOIN tn.taxon AS t "

                + "   INNER JOIN t.name AS name "

                + "   LEFT OUTER JOIN name.rank AS rank "

//                + "   LEFT OUTER JOIN tn.taxon.name.rank AS rank "

                + " WHERE t.uuid = :uuid ";

        if(classificationUuid != null){

            queryString += "AND cls.uuid = :classificationUuid";

        }

        Query query =  getSession().createQuery(queryString);

        query.setParameter("uuid", taxonUUID);

        if(classificationUuid != null){

            query.setParameter("classificationUuid", classificationUuid);

        }

        @SuppressWarnings("unchecked")

        List<SortableTaxonNodeQueryResult> result = query.list();

        Collections.sort(result, new SortableTaxonNodeQueryResultComparator());

        List<TaxonNodeDto> list = new ArrayList<>();

        for(SortableTaxonNodeQueryResult queryDTO : result){

            list.add(new TaxonNodeDto(queryDTO.getTaxonNodeUuid(), queryDTO.getTaxonNodeId(), queryDTO.getTaxonTitleCache(), queryDTO.getNameRank().getOrderIndex()));

        }

        return list;

    }

import java.util.HashMap;

import java.util.Map;

    @Override

    public TermDto findByUUIDAsDto(UUID uuid) {

        String queryString = TermDto.getTermDtoSelect()

                + " where a.uuid like :uuid ";

        Query query =  getSession().createQuery(queryString);

        query.setParameter("uuid", uuid);

        @SuppressWarnings("unchecked")

        List<Object[]> result = query.list();

        List<TermDto> list = TermDto.termDtoListFrom(result);

        if (list.size()== 1){

            return list.get(0);

        }else{

            return null;

        }

    }

    public  Map<UUID, List<TermDto>> getSupportedStatesForFeature(Set<UUID> featureUuids){

        Map<UUID, List<TermDto>> map = new HashMap<>();

        for (UUID featureUuid: featureUuids){

            List<TermDto> list = new ArrayList<>();

            String supportedCategoriesQueryString = "SELECT cat.uuid "

                    + "from DefinedTermBase t "

                    + "join t.supportedCategoricalEnumerations as cat "

                    + "where t.uuid = :featureUuid";

            Query supportedCategoriesQuery =  getSession().createQuery(supportedCategoriesQueryString);

            supportedCategoriesQuery.setParameter("featureUuid", featureUuid);

            @SuppressWarnings("unchecked")

    		List<UUID> supportedCategories = supportedCategoriesQuery.list();

            if(supportedCategories.isEmpty()){

                map.put(featureUuid, list);

                continue;

            }

            String queryString = TermDto.getTermDtoSelect()

                    + "where v.uuid in (:supportedCategories) "

                    + "order by a.titleCache";

            Query query =  getSession().createQuery(queryString);

            query.setParameterList("supportedCategories", supportedCategories);

            @SuppressWarnings("unchecked")

            List<Object[]> result = query.list();

            list = TermDto.termDtoListFrom(result);

            map.put(featureUuid, list);

        }

        return map;

    @Override

    public TermDto getTermDto(UUID uuid) {

        String queryString = TermDto.getTermDtoSelect()

                + " where a.uuid = :uuid ";

        Query query =  getSession().createQuery(queryString);

        query.setParameter("uuid", uuid);

        @SuppressWarnings("unchecked")

        List<Object[]> result = query.list();

        TermDto dto = null;

        List<TermDto> dtoList = TermDto.termDtoListFrom(result);

        if (dtoList != null && !dtoList.isEmpty()){

            dto = dtoList.get(0);

        }

        return dto;

    }

import java.util.ArrayList;

import java.util.UUID;

import org.hibernate.Query;

import org.hibernate.Session;

import eu.etaxonomy.cdm.persistence.dto.SortableTaxonNodeQueryResult;

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

	@Override

	public List<UuidAndTitleCache<TermNode>> getUuidAndTitleCache(Integer limit, String pattern){

	    Session session = getSession();

        Query query = session.createQuery(

                "SELECT new " + SortableTaxonNodeQueryResult.class.getName() + "("

                + " uuid, id, titleCache "

                + ") "

                + " FROM TermNode node "

                + " JOIN DefinedTerm term ON node.term = term "

                + (pattern!=null?" WHERE term.titleCache LIKE :pattern":""));

        if(pattern!=null){

            pattern = pattern.replace("*", "%");

            pattern = pattern.replace("?", "_");

            pattern = pattern + "%";

            query.setParameter("pattern", pattern);

        }

        if (limit != null){

           query.setMaxResults(limit);

        }

        return getUuidAndTitleCache(query);

	}

	 protected List<UuidAndTitleCache<TermNode>> getUuidAndTitleCache(Query query){

	        List<UuidAndTitleCache<TermNode>> list = new ArrayList<>();

	        List<Object> result = query.list();

	        for(Object obj : result){

	            if (obj instanceof SortableTaxonNodeQueryResult) {

	                SortableTaxonNodeQueryResult stnqr = (SortableTaxonNodeQueryResult) obj;

	                list.add(new UuidAndTitleCache<>(stnqr.getTaxonNodeUuid(),stnqr.getTaxonNodeId(), stnqr.getTaxonTitleCache()));

	            }else{

	                Object[] object = (Object[])obj;

	                list.add(new UuidAndTitleCache<>((UUID) object[0],(Integer) object[1], (String) object[2]));

	            }

	        }

	        return list;

	    }

import eu.etaxonomy.cdm.persistence.dto.CharacterDto;

    public List<TermDto> getTopLevelTerms(UUID vocabularyUuid, TermType type) {

            if (type.equals(TermType.Character)){

                queryString = CharacterDto.getTermDtoSelect();

            }else{

                queryString = FeatureDto.getTermDtoSelect();

            }

                + " where v.uuid = :vocabularyUuid ";

//                + "and a.partOf is null "

//                + "and a.kindOf is null";

            if (type.equals(TermType.Character)){

                list = CharacterDto.termDtoListFrom(result);

            }else{

                list = FeatureDto.termDtoListFrom(result);

            }

    /**

     * @param taxonUUID

     * @param classificationUuid

     * @return

     */

    List<TaxonNodeDto> getTaxonNodeForTaxonInClassificationDto(UUID taxonUUID, UUID classificationUuid);

    /**

     * @param nodeUuid

     * @return

     */

    TaxonNodeDto getTaxonNodeDto(UUID nodeUuid);

    /**

     * @param nodeUuid

     * @return

     */

    List<TaxonNodeDto> getTaxonNodeDtos(List<UUID> nodeUuid);

import java.util.Map;

    public TermDto getTermDto(UUID uuid);

     * Returns all states for all supportedCategoricalEnumeration of the categorical features

     * @param set of featureUuids the feature which has to support categorical data

     * @return map of lists of all supported states

    public Map<UUID, List<TermDto>> getSupportedStatesForFeature(Set<UUID> featureUuids);

    public TermDto findByUUIDAsDto(UUID uuid);

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

    /**

     * @param limit

     * @param pattern

     * @return

     */

    List<UuidAndTitleCache<TermNode>> getUuidAndTitleCache(Integer limit, String pattern);

    public List<TermDto> getTopLevelTerms(UUID vocabularyUuid, TermType type);

            UUID vocabularyUuid, Integer orderIndex, String idInVocabulary, //Set<Representation> vocRepresentations,

                isAvailableForTaxon, isAvailableForTaxonName, isAvailableForOccurrence, titleCache, isSupportCategoricalData, isSupportsQuantitativeData, supportedCategoricalEnumerations, recommendedModifierEnumeration, recommendedMeasurementUnits, recommendedStatisticalMeasures);

               voc != null? voc.getUuid(): null, null, character.getIdInVocabulary(), character.isAvailableForTaxon(), character.isAvailableForTaxonName(), character.isAvailableForOccurrence(), character.getTitleCache(),

//                + "voc_rep,  "

//                if(elements[6]!=null){

//                    dtoMap.get(uuid).addVocRepresentation((Representation)elements[6]);

//                }

                if(elements[8]!=null){

                    dtoMap.get(uuid).addMedia(((Media) elements[8]).getUuid());

                if(elements[8] instanceof Media) {

                    mediaUuids.add(((Media) elements[8]).getUuid());

//                Set<Representation> vocRepresentations = new HashSet<>();

//                if(elements[6] instanceof Representation) {

//                    vocRepresentations = new HashSet<Representation>(7);

//                    vocRepresentations.add((Representation)elements[6]);

//                }

                EnumSet<CdmClass> availableForString = (EnumSet<CdmClass>)elements[9];

                EnumSet<CdmClass> supportsString = (EnumSet<CdmClass>)elements[11];

                Object o = elements[12];

                o = elements[13];

                o =  elements[14];

                o = elements[15];

                    Set<MeasurementUnit> recommendedMeasurementUnits = (Set<MeasurementUnit>) elements[15];

                o = elements[16];

                o = elements[17];

                o = elements[9];

//                        vocRepresentations,

                        (String)elements[10],structure, null, prop, null, ratioTo, isSupportsCategoricalData,

                termDto.setUri((URI)elements[7]);

/**

* Copyright (C) 2021 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.persistence.dto;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import eu.etaxonomy.cdm.model.description.DescriptiveDataSet;

import eu.etaxonomy.cdm.model.term.Representation;

/**

 * @author k.luther

 * @since Aug 31, 2021

 */

public class DescriptiveDataSetBaseDto implements Serializable{

    private static final long serialVersionUID = 7310069387512600745L;

    private UUID uuid;

    private Integer id;

    private String titleCache;

    private TermTreeDto descriptiveSystem;

    private Set<TaxonNodeDto> subTreeFilter;

    private Set<TermDto> geoFilter;

    private Set<Representation> representations = new HashSet<>();

    private String representation_L10n = null;

    private String representation_L10n_abbreviatedLabel = null;

    private String representation_L10n_text = null;

    private TermDto maxRank;

    private TermDto minRank;

    public DescriptiveDataSetBaseDto(UUID uuid, Integer id, String titleCache){

        this.uuid = uuid;

        this.id = id;

        this.titleCache = titleCache;

    }

    public UUID getUuid() {

        return uuid;

    }

    public void setUuid(UUID uuid) {

        this.uuid = uuid;

    }

    public Integer getId() {

        return id;

    }

    public void setId(Integer id) {

        this.id = id;

    }

    public String getTitleCache() {

        return titleCache;

    }

    public void setTitleCache(String titleCache) {

        this.titleCache = titleCache;

    }

    public TermTreeDto getDescriptiveSystem() {

        return descriptiveSystem;

    }

    public void setDescriptiveSystem(TermTreeDto descriptiveSystem) {

        this.descriptiveSystem = descriptiveSystem;

    }

    private void addRepresentation(Representation representation) {

        if (this.representations == null){

            this.representations = new HashSet<>();

        }

        this.representations.add(representation);

    }

    public TermDto getMaxRank() {

        return maxRank;

    }

    public void setMaxRank(TermDto minRank) {

        this.maxRank = minRank;

    }

    public TermDto getMinRank() {

        return minRank;

    }

    public void setMinRank(TermDto minRank) {

        this.minRank = minRank;

    }

    /** sql queries to get descriptive data set dto*/

    public static String getDescriptiveDataSetDtoSelect(){

        String[] result = createSqlParts();

        return result[0]+result[1]+result[2];

    }

    private static String[] createSqlParts() {

        String sqlSelectString = ""

                + "select a.uuid, "

                + "a.id, "

                + "a.titleCache, "

                + "r, "

                + "d.uuid, "

                + "minRank.uuid, "

//                + "minRank.representations, "

//                + "minRank.termType, "

//                + "minRank.orderIndex, "

//                + "minRank.idInVocabulary, "

//                + "minRank.titleCache, "

                + "maxRank.uuid ";

//                + "maxRank.representations, "

//                + "maxRank.termType, "

//                + "maxRank.orderIndex, "

//                + "maxRank.idInVocabulary, "

//                + "maxRank.titleCache ";

        //UUID uuid, Set<Representation> representations, TermType termType, UUID partOfUuid, UUID kindOfUuid,

       // UUID vocabularyUuid, Integer orderIndex, String idInVocabulary, String titleCache

        String sqlFromString =   " FROM DescriptiveDataSet as a ";

        String sqlJoinString =  " LEFT JOIN a.descriptiveSystem as d "

                + " LEFT JOIN a.representations AS r "

                + " LEFT JOIN a.minRank as minRank "

                + " LEFT JOIN a.maxRank as maxRank ";

        String[] result = new String[3];

        result[0] = sqlSelectString;

        result[1] = sqlFromString;

        result[2] = sqlJoinString;

        return result;

    }

    /**

     * @param result

     * @return

     */

    public static List<DescriptiveDataSetBaseDto> descriptiveDataSetBaseDtoListFrom(List<Object[]> results) {

            List<DescriptiveDataSetBaseDto> dtos = new ArrayList<>(); // list to ensure order

            // map to handle multiple representations/media/vocRepresentation because of LEFT JOIN

            Map<UUID, DescriptiveDataSetBaseDto> dtoMap = new HashMap<>(results.size());

            for (Object[] elements : results) {

                UUID uuid = (UUID)elements[0];

                Integer id = (Integer)elements[1];

                if(dtoMap.containsKey(uuid)){

                    // multiple results for one dataset -> multiple (voc) representation/media

                    if(elements[1]!=null){

                        dtoMap.get(uuid).addRepresentation((Representation)elements[1]);

                    }

                } else {

                    // dataset representation

                    Set<Representation> representations = new HashSet<>();

                    if(elements[1] instanceof Representation) {

                        representations = new HashSet<>(1);

                        representations.add((Representation)elements[1]);

                    }

                    DescriptiveDataSetBaseDto datasetDto = new DescriptiveDataSetBaseDto(

                            uuid,

                            id,

                            (String)elements[2]);

//                    TermDto minRank = new TermDto((UUID)elements[5], (Set<Representation>)elements[6], (TermType)elements[7], null, null, null, (Integer)elements[8], (String)elements[9], (String)elements[10]);

//                    TermDto maxRank = new TermDto((UUID)elements[11], (Set<Representation>)elements[12], (TermType)elements[13], null, null, null, (Integer)elements[14], (String)elements[15], (String)elements[16]);

//                    datasetDto.setMinRank(minRank);

//                    datasetDto.setMaxRank(maxRank);

                    dtoMap.put(uuid, datasetDto);

                    dtos.add(datasetDto);

                }

            }

            return dtos;

        }

    public static DescriptiveDataSetBaseDto fromDescriptiveDataSet(DescriptiveDataSet dataSet){

        DescriptiveDataSetBaseDto dto = new DescriptiveDataSetBaseDto(dataSet.getUuid(), dataSet.getId(), dataSet.getTitleCache());

        if (dataSet.getDescriptiveSystem() != null){

            dto.setDescriptiveSystem(TermTreeDto.fromTree(dataSet.getDescriptiveSystem()));

        }

        return dto;

    }

    public Set<TaxonNodeDto> getSubTreeFilter() {

        return subTreeFilter;

    }

    public void setSubTreeFilter(Set<TaxonNodeDto> subTreeFilter) {

        this.subTreeFilter = subTreeFilter;

    }

    public Set<TermDto> getGeoFilter() {

        return geoFilter;

    }

    public void setGeoFilter(Set<TermDto> geoFilter) {

        this.geoFilter = geoFilter;

    }

}

            UUID vocabularyUuid, Integer orderIndex, String idInVocabulary, //Set<Representation> vocRepresentations,

            boolean isAvailableForTaxon, boolean isAvailableForTaxonName, boolean isAvailableForOccurrence, String titleCache, boolean isSupportsCategoricalData, boolean isSupportsQuantitativeData,

                vocabularyUuid, orderIndex, idInVocabulary, titleCache);

    static public FeatureDto fromFeature(Feature term) {

        UUID partOfUuid = term.getPartOf() != null? term.getPartOf().getUuid(): null;

        UUID kindOfUuid = term.getKindOf() != null? term.getKindOf().getUuid(): null;

        UUID vocUuid =  term.getVocabulary() != null? term.getVocabulary().getUuid(): null;

        Set<TermVocabularyDto> supportedCategoricalEnumerations = new HashSet<>();

        for (TermVocabulary<State> stateVoc:term.getSupportedCategoricalEnumerations()){

            supportedCategoricalEnumerations.add(TermVocabularyDto.fromVocabulary(stateVoc));

        }

        Set<TermVocabularyDto> recommendedModifiers = new HashSet<>();

        for (TermVocabulary<DefinedTerm> modifier:term.getRecommendedModifierEnumeration()){

            recommendedModifiers.add(TermVocabularyDto.fromVocabulary(modifier));

        }

        Set<TermDto> recommendedMeasurementUnits= new HashSet<>();

        for (MeasurementUnit measurementUnit:term.getRecommendedMeasurementUnits()){

            recommendedMeasurementUnits.add(TermDto.fromTerm(measurementUnit));

        }

        Set<TermDto> recommendedStatisticalMeasures = new HashSet<>();

        for (StatisticalMeasure statMeasure:term.getRecommendedStatisticalMeasures()){

            recommendedStatisticalMeasures.add(TermDto.fromTerm(statMeasure));

        }

        FeatureDto result =  new FeatureDto(term.getUuid(), term.getRepresentations(), partOfUuid, kindOfUuid, vocUuid, null, term.getIdInVocabulary(), term.isAvailableForTaxon(), term.isAvailableForTaxonName(), term.isAvailableForOccurrence(),

                term.getTitleCache(),term.isSupportsCategoricalData(), term.isSupportsQuantitativeData(), supportedCategoricalEnumerations, recommendedModifiers, recommendedMeasurementUnits, recommendedStatisticalMeasures);

//                + "voc_rep,  "

//                + "LEFT JOIN v.representations as voc_rep "

//                if(elements[7]!=null){

//                    dtoMap.get(uuid).addVocRepresentation((Representation)elements[7]);

//                }

                if(elements[9]!=null){

                    dtoMap.get(uuid).addMedia(((Media) elements[9]).getUuid());

                if(elements[9] instanceof Media) {

                    mediaUuids.add(((Media) elements[9]).getUuid());

//                Set<Representation> vocRepresentations = new HashSet<>();

//                if(elements[7] instanceof Representation) {

//                    vocRepresentations = new HashSet<Representation>(7);

//                    vocRepresentations.add((Representation)elements[7]);

//                }

                EnumSet<CdmClass> availableForString = (EnumSet<CdmClass>)elements[10];

                EnumSet<CdmClass> supportsString = (EnumSet<CdmClass>)elements[12];

                Object o = elements[13];

                o = elements[14];

                o =  elements[15];

                o = elements[16];

                    Set<MeasurementUnit> recommendedMeasurementUnits = (Set<MeasurementUnit>) elements[16];

//                        vocRepresentations,

                        (String)elements[11],

                termDto.setUri((URI)elements[8]);

    public TaxonNodeDto(UUID uuid, Integer id, String titleCache, Integer rankOrderIndex) {

        super(uuid, id, titleCache);

        this.rankOrderIndex = rankOrderIndex;

    }

    private boolean isAllowModifications = true;

//    this should be handled in vocabularyDto

//    private Set<Representation> vocRepresentations = null;

//    private String vocRepresentation_L10n = null;

//    private String vocRepresentation_L10n_abbreviatedLabel = null;

//    private TermDto(UUID uuid, Set<Representation> representations, TermType termType, UUID partOfUuid, UUID kindOfUuid,

//            UUID vocabularyUuid, Integer orderIndex, String idInVocabulary, String titleCache) {

//        this(uuid, representations, termType, partOfUuid, kindOfUuid, vocabularyUuid, orderIndex, idInVocabulary, titleCache);

//    }

            UUID vocabularyUuid, Integer orderIndex, String idInVocabulary, String titleCache) {

//        this.vocRepresentations = vocRepresentations;

//        if(vocRepresentations!=null){

//            representation_L10n.localize(vocRepresentations);

//            if (representation_L10n.getLabel() != null) {

//                setVocRepresentation_L10n(representation_L10n.getLabel());

//            }

//            if (representation_L10n.getAbbreviatedLabel() != null) {

//                setVocRepresentation_L10n_abbreviatedLabel(representation_L10n.getAbbreviatedLabel());

//            }

//        }

//    public void setVocRepresentation_L10n(String vocRepresentation_L10n) {

//        this.vocRepresentation_L10n = vocRepresentation_L10n;

//    }

//

        return vocabularyDto.getRepresentation_L10n();

//

//    public void setVocRepresentation_L10n_abbreviatedLabel(String vocRepresentation_L10n_abbreviatedLabel) {

//        this.vocRepresentation_L10n_abbreviatedLabel = vocRepresentation_L10n_abbreviatedLabel;

//    }

//

        return vocabularyDto.getRepresentation_L10n_abbreviatedLabel();

//

//    protected void addVocRepresentation(Representation vocRepresentation){

//        this.vocRepresentations.add(vocRepresentation);

//    }

//                + "voc_rep,  "

//                + "LEFT JOIN v.representations as voc_rep "

//                if(elements[7]!=null){

//                    dtoMap.get(uuid).addVocRepresentation((Representation)elements[7]);

//                }

                if(elements[9]!=null){

                    dtoMap.get(uuid).addMedia(((Media) elements[9]).getUuid());

                if(elements[9] instanceof Media) {

                    mediaUuids.add(((Media) elements[9]).getUuid());

//                Set<Representation> vocRepresentations = new HashSet<>();

//                if(elements[7] instanceof Representation) {

//                    vocRepresentations = new HashSet<>(7);

//                    vocRepresentations.add((Representation)elements[7]);

//                }

                        (TermType)elements[7],