Examples with QuantitativeDataDto eu.etaxonomy.cdm.api.service.dto.QuantitativeDataDto used on opensource projects

Example 1 with QuantitativeDataDto

use of eu.etaxonomy.cdm.api.service.dto.QuantitativeDataDto in project cdmlib by cybertaxonomy.

the class DescriptiveDataSetService method addRowWrapperToDataset.

@Override
@Transactional(readOnly = false)
public UpdateResult addRowWrapperToDataset(Collection<SpecimenRowWrapperDTO> wrappers, UUID datasetUuid, boolean addDatasetSource) {
    UpdateResult result = new UpdateResult();
    DescriptiveDataSet dataSet = load(datasetUuid);
    result.setCdmEntity(dataSet);
    List<UUID> taxonUuids = wrappers.stream().map(wrapper -> wrapper.getTaxonNode().getTaxonUuid()).collect(Collectors.toList());
    List<TaxonBase> taxa = taxonService.load(taxonUuids, Arrays.asList(new String[] { "descriptions" }));
    for (SpecimenRowWrapperDTO wrapper : wrappers) {
        Optional<TaxonBase> findAny = taxa.stream().filter(taxon -> taxon.getUuid().equals(wrapper.getTaxonNode().getTaxonUuid())).findAny();
        if (!findAny.isPresent()) {
            result.addException(new IllegalArgumentException("Could not create wrapper for " + wrapper.getSpecimenDto().getLabel()));
            continue;
        }
        Taxon taxon = (Taxon) findAny.get();
        SpecimenOrObservationBase<?> specimen = occurrenceService.load(wrapper.getSpecimenDto().getUuid());
        TaxonDescription taxonDescription = taxon.getDescriptions().stream().filter(desc -> desc.getTypes().contains(DescriptionType.INDIVIDUALS_ASSOCIATION)).findFirst().orElseGet(() -> {
            TaxonDescription td = TaxonDescription.NewInstance(taxon);
            td.addType(DescriptionType.INDIVIDUALS_ASSOCIATION);
            td.setTitleCache("Specimens used by " + dataSet.getTitleCache() + " for " + getTaxonLabel(taxon), true);
            return td;
        });
        IndividualsAssociation association = null;
        for (DescriptionElementBase el : taxonDescription.getElements()) {
            if (el instanceof IndividualsAssociation) {
                IndividualsAssociation indAss = (IndividualsAssociation) el;
                if (indAss.getAssociatedSpecimenOrObservation().getUuid().equals(specimen.getUuid())) {
                    association = indAss;
                }
            }
        }
        if (association == null) {
            association = IndividualsAssociation.NewInstance(specimen);
            taxonDescription.addElement(association);
            taxonService.saveOrUpdate(taxon);
            result.addUpdatedObject(taxon);
        }
        UUID specimenDescriptionUuid = wrapper.getDescription().getDescriptionUuid();
        DescriptionBaseDto descriptionDto = wrapper.getDescription();
        DescriptionBase<?> specimenDescription = descriptionService.load(specimenDescriptionUuid);
        // if description already exist use the loaded one and add changed data otherwise create a new one and add to specimen
        if (specimenDescription == null) {
            specimenDescription = SpecimenDescription.NewInstance(specimen);
            specimenDescription.setUuid(specimenDescriptionUuid);
            List<DescriptionElementDto> elementDtos = descriptionDto.getElements();
            for (DescriptionElementDto elementDto : elementDtos) {
                if (elementDto instanceof CategoricalDataDto) {
                    eu.etaxonomy.cdm.model.description.Character feature = DefinedTermBase.getTermByClassAndUUID(eu.etaxonomy.cdm.model.description.Character.class, elementDto.getFeatureUuid());
                    CategoricalData data = CategoricalData.NewInstance(feature);
                    for (StateDataDto stateDto : ((CategoricalDataDto) elementDto).getStates()) {
                        State state = DefinedTermBase.getTermByClassAndUUID(State.class, stateDto.getState().getUuid());
                        data.addStateData(state);
                        specimenDescription.addElement(data);
                    }
                }
                if (elementDto instanceof QuantitativeDataDto) {
                    eu.etaxonomy.cdm.model.description.Character feature = DefinedTermBase.getTermByClassAndUUID(eu.etaxonomy.cdm.model.description.Character.class, elementDto.getFeatureUuid());
                    QuantitativeData data = QuantitativeData.NewInstance(feature);
                    if (((QuantitativeDataDto) elementDto).getMeasurementUnit() != null) {
                        MeasurementUnit unit = DefinedTermBase.getTermByClassAndUUID(MeasurementUnit.class, ((QuantitativeDataDto) elementDto).getMeasurementUnit().getUuid());
                        data.setUnit(unit);
                    }
                    for (StatisticalMeasurementValueDto stateDto : ((QuantitativeDataDto) elementDto).getValues()) {
                        StatisticalMeasure statMeasure = DefinedTermBase.getTermByClassAndUUID(StatisticalMeasure.class, stateDto.getType().getUuid());
                        StatisticalMeasurementValue value = StatisticalMeasurementValue.NewInstance(statMeasure, stateDto.getValue());
                        data.addStatisticalValue(value);
                        specimenDescription.addElement(data);
                    }
                }
            }
        } else {
            List<DescriptionElementDto> elementDtos = descriptionDto.getElements();
            for (DescriptionElementDto elementDto : elementDtos) {
                if (elementDto instanceof CategoricalDataDto) {
                    eu.etaxonomy.cdm.model.description.Character feature = DefinedTermBase.getTermByClassAndUUID(eu.etaxonomy.cdm.model.description.Character.class, elementDto.getFeatureUuid());
                    List<DescriptionElementBase> uniqueElementList = specimenDescription.getElements().stream().filter(element -> element.getUuid().equals(elementDto.getElementUuid())).collect(Collectors.toList());
                    List<State> allStates = new ArrayList<>();
                    CategoricalData element = null;
                    if (uniqueElementList.size() == 1) {
                        element = HibernateProxyHelper.deproxy(uniqueElementList.get(0), CategoricalData.class);
                    } else {
                        element = CategoricalData.NewInstance(feature);
                    }
                    for (StateDataDto stateDto : ((CategoricalDataDto) elementDto).getStates()) {
                        State state = DefinedTermBase.getTermByClassAndUUID(State.class, stateDto.getState().getUuid());
                        allStates.add(state);
                    }
                    element.setStateDataOnly(allStates);
                }
                if (elementDto instanceof QuantitativeDataDto) {
                    eu.etaxonomy.cdm.model.description.Character feature = DefinedTermBase.getTermByClassAndUUID(eu.etaxonomy.cdm.model.description.Character.class, elementDto.getFeatureUuid());
                    QuantitativeData data = QuantitativeData.NewInstance(feature);
                    if (((QuantitativeDataDto) elementDto).getMeasurementUnit() != null) {
                        MeasurementUnit unit = DefinedTermBase.getTermByClassAndUUID(MeasurementUnit.class, ((QuantitativeDataDto) elementDto).getMeasurementUnit().getUuid());
                        data.setUnit(unit);
                    }
                    for (StatisticalMeasurementValueDto stateDto : ((QuantitativeDataDto) elementDto).getValues()) {
                        StatisticalMeasure statMeasure = DefinedTermBase.getTermByClassAndUUID(StatisticalMeasure.class, stateDto.getType().getUuid());
                        StatisticalMeasurementValue value = StatisticalMeasurementValue.NewInstance(statMeasure, stateDto.getValue());
                        data.addStatisticalValue(value);
                        specimenDescription.addElement(data);
                    }
                }
            }
        }
        if (addDatasetSource) {
            for (IdentifiableSource source : dataSet.getSources()) {
                try {
                    specimenDescription.addSource(source.clone());
                } catch (CloneNotSupportedException e) {
                // nothing
                }
            }
        }
        // add specimen description to data set
        specimenDescription.addDescriptiveDataSet(dataSet);
        // add taxon description with IndividualsAssociation to the specimen to data set
        taxonDescription.addDescriptiveDataSet(dataSet);
        result.addUpdatedObject(specimen);
        result.addUpdatedObject(specimenDescription);
        result.addUpdatedObject(taxonDescription);
    }
    saveOrUpdate(dataSet);
    return result;
}

Example 2 with QuantitativeDataDto

use of eu.etaxonomy.cdm.api.service.dto.QuantitativeDataDto in project cdmlib by cybertaxonomy.

the class DescriptionServiceImpl method mergeDescriptions.

@Override
@Transactional(readOnly = false)
public UpdateResult mergeDescriptions(Collection<DescriptionBaseDto> descriptions, UUID descriptiveDataSetUuid) {
    UpdateResult result = new UpdateResult();
    DescriptiveDataSet dataSet = descriptiveDataSetDao.load(descriptiveDataSetUuid);
    Set<DescriptionBase> descriptionsOfDataSet = dataSet.getDescriptions();
    HashMap<UUID, Set<DescriptionBase>> descriptionSpecimenMap = new HashMap<>();
    Set<DescriptionBase> specimenDescriptions;
    for (DescriptionBase<?> descriptionBase : descriptionsOfDataSet) {
        if (descriptionBase.getDescribedSpecimenOrObservation() != null) {
            specimenDescriptions = descriptionSpecimenMap.get(descriptionBase.getDescribedSpecimenOrObservation().getUuid());
            if (specimenDescriptions == null) {
                specimenDescriptions = new HashSet<>();
            }
            specimenDescriptions.add(descriptionBase);
            descriptionSpecimenMap.put(descriptionBase.getDescribedSpecimenOrObservation().getUuid(), specimenDescriptions);
        }
        if (descriptionBase instanceof TaxonDescription) {
            specimenDescriptions = descriptionSpecimenMap.get(((TaxonDescription) descriptionBase).getTaxon().getUuid());
            if (specimenDescriptions == null) {
                specimenDescriptions = new HashSet<>();
            }
            specimenDescriptions.add(descriptionBase);
            descriptionSpecimenMap.put(((TaxonDescription) descriptionBase).getTaxon().getUuid(), specimenDescriptions);
        }
        if (descriptionBase instanceof TaxonNameDescription) {
            specimenDescriptions = descriptionSpecimenMap.get(((TaxonNameDescription) descriptionBase).getTaxonName().getUuid());
            if (specimenDescriptions == null) {
                specimenDescriptions = new HashSet<>();
            }
            specimenDescriptions.add(descriptionBase);
            descriptionSpecimenMap.put(((TaxonNameDescription) descriptionBase).getTaxonName().getUuid(), specimenDescriptions);
        }
    }
    MergeResult<DescriptionBase> mergeResult = null;
    for (DescriptionBaseDto descDto : descriptions) {
        UUID descriptionUUID = descDto.getDescriptionUuid();
        DescriptionBase<?> description = load(descriptionUUID);
        UUID describedObjectUuid = null;
        if (description instanceof SpecimenDescription) {
            describedObjectUuid = descDto.getSpecimenDto().getUuid();
        } else if (description instanceof TaxonDescription) {
            describedObjectUuid = descDto.getTaxonDto().getUuid();
        } else if (description instanceof TaxonNameDescription) {
            describedObjectUuid = descDto.getNameDto().getUuid();
        }
        Set<DescriptionBase> descSpecimen = descriptionSpecimenMap.get(describedObjectUuid);
        if (descSpecimen != null) {
            // TODO: elements are Dtos now, no cdm entities, needs to get the value and replace or create new description element
            Set<DescriptionElementDto> elements = new HashSet<>();
            for (Object element : descDto.getElements()) {
                elements.add((DescriptionElementDto) element);
            }
            DescriptionBase<?> desc = null;
            for (DescriptionBase<?> tempDesc : descSpecimen) {
                if (tempDesc.getUuid().equals(descDto.getDescriptionUuid())) {
                    desc = tempDesc;
                    break;
                }
            }
            Set<DescriptionElementBase> removeElements = new HashSet<>();
            Set<DescriptionElementBase> descriptionElements = desc.getElements();
            for (DescriptionElementBase elementBase : descriptionElements) {
                UUID descElementUuid = elementBase.getUuid();
                if (descElementUuid != null) {
                    List<DescriptionElementDto> equalUuidsElements = elements.stream().filter(e -> e != null && e.getElementUuid() != null && e.getElementUuid().equals(descElementUuid)).collect(Collectors.toList());
                    if (equalUuidsElements.size() == 0 || (equalUuidsElements.size() == 1 && equalUuidsElements.get(0) instanceof QuantitativeDataDto && ((QuantitativeDataDto) equalUuidsElements.get(0)).getValues().isEmpty())) {
                        removeElements.add(elementBase);
                    }
                }
            }
            if (!removeElements.isEmpty()) {
                for (DescriptionElementBase el : removeElements) {
                    desc.removeElement(el);
                }
            }
            for (DescriptionElementDto descElement : elements) {
                if (descElement == null) {
                    continue;
                }
                UUID descElementUuid = descElement.getElementUuid();
                if (descElement instanceof CategoricalDataDto && ((CategoricalDataDto) descElement).getStates().isEmpty() || descElement instanceof QuantitativeDataDto && ((QuantitativeDataDto) descElement).getValues().isEmpty()) {
                    continue;
                }
                List<DescriptionElementBase> equalUuidsElements = descriptionElements.stream().filter(e -> e.getUuid().equals(descElementUuid)).collect(Collectors.toList());
                eu.etaxonomy.cdm.model.description.Feature feature = DefinedTermBase.getTermByClassAndUUID(eu.etaxonomy.cdm.model.description.Feature.class, descElement.getFeatureUuid());
                if (feature == null) {
                    feature = DefinedTermBase.getTermByClassAndUUID(eu.etaxonomy.cdm.model.description.Character.class, descElement.getFeatureUuid());
                }
                if (equalUuidsElements.size() == 0) {
                    if (descElement instanceof CategoricalDataDto) {
                        CategoricalData elementBase = CategoricalData.NewInstance(feature);
                        List<StateDataDto> stateDtos = ((CategoricalDataDto) descElement).getStates();
                        for (StateDataDto dataDto : stateDtos) {
                            // create new statedata
                            State newState = DefinedTermBase.getTermByClassAndUUID(State.class, dataDto.getState().getUuid());
                            StateData newStateData = StateData.NewInstance(newState);
                            elementBase.addStateData(newStateData);
                        }
                        desc.addElement(elementBase);
                    }
                    if (descElement instanceof QuantitativeDataDto) {
                        QuantitativeData data = QuantitativeData.NewInstance(feature);
                        if (((QuantitativeDataDto) descElement).getMeasurementUnit() != null) {
                            MeasurementUnit unit = DefinedTermBase.getTermByClassAndUUID(MeasurementUnit.class, ((QuantitativeDataDto) descElement).getMeasurementUnit().getUuid());
                            data.setUnit(unit);
                        }
                        Set<StatisticalMeasurementValue> statisticalValues = new HashSet<>();
                        Set<StatisticalMeasurementValueDto> valueDtos = ((QuantitativeDataDto) descElement).getValues();
                        data.getStatisticalValues().clear();
                        for (StatisticalMeasurementValueDto dataDto : valueDtos) {
                            // create new statedata
                            StatisticalMeasurementValue newStatisticalMeasurement = StatisticalMeasurementValue.NewInstance(DefinedTermBase.getTermByClassAndUUID(StatisticalMeasure.class, dataDto.getType().getUuid()), dataDto.getValue());
                            statisticalValues.add(newStatisticalMeasurement);
                            data.addStatisticalValue(newStatisticalMeasurement);
                        }
                        // data.getStatisticalValues().addAll(statisticalValues);
                        data = StructuredDescriptionAggregation.handleMissingMinOrMax(data, MissingMinimumMode.MinToZero, MissingMaximumMode.MaxToMin);
                        desc.addElement(data);
                    }
                // create new element
                } else {
                    DescriptionElementBase elementBase = equalUuidsElements.get(0);
                    if (elementBase.isInstanceOf(CategoricalData.class)) {
                        CategoricalData data = HibernateProxyHelper.deproxy(elementBase, CategoricalData.class);
                        List<StateData> states = new ArrayList<>(data.getStateData());
                        List<StateDataDto> stateDtos = ((CategoricalDataDto) descElement).getStates();
                        data.getStateData().clear();
                        if (stateDtos.isEmpty()) {
                            desc.removeElement(data);
                        } else {
                            for (StateDataDto dataDto : stateDtos) {
                                State newState = DefinedTermBase.getTermByClassAndUUID(State.class, dataDto.getState().getUuid());
                                StateData newStateData = StateData.NewInstance(newState);
                                data.addStateData(newStateData);
                            }
                        }
                    } else if (elementBase.isInstanceOf(QuantitativeData.class)) {
                        QuantitativeData data = HibernateProxyHelper.deproxy(elementBase, QuantitativeData.class);
                        Set<StatisticalMeasurementValue> statisticalValues = new HashSet<>();
                        if (((QuantitativeDataDto) descElement).getMeasurementUnit() != null) {
                            MeasurementUnit unit = DefinedTermBase.getTermByClassAndUUID(MeasurementUnit.class, ((QuantitativeDataDto) descElement).getMeasurementUnit().getUuid());
                            if (data.getUnit() == null || (data.getUnit() != null && !data.getUnit().equals(unit))) {
                                data.setUnit(unit);
                            }
                        }
                        Set<StatisticalMeasurementValueDto> valueDtos = ((QuantitativeDataDto) descElement).getValues();
                        data.getStatisticalValues().clear();
                        if (valueDtos.isEmpty()) {
                            desc.removeElement(data);
                        } else {
                            for (StatisticalMeasurementValueDto dataDto : valueDtos) {
                                // create new statedata
                                StatisticalMeasure statMeasure = DefinedTermBase.getTermByClassAndUUID(StatisticalMeasure.class, dataDto.getType().getUuid());
                                StatisticalMeasurementValue newStatisticalMeasurement = StatisticalMeasurementValue.NewInstance(statMeasure, dataDto.getValue());
                                statisticalValues.add(newStatisticalMeasurement);
                                data.addStatisticalValue(newStatisticalMeasurement);
                            }
                            // data.getStatisticalValues().addAll(statisticalValues);
                            data = StructuredDescriptionAggregation.handleMissingMinOrMax(data, MissingMinimumMode.MinToZero, MissingMaximumMode.MaxToMin);
                        }
                    }
                }
            // remove deleted elements
            }
            descriptionSpecimenMap.get(describedObjectUuid).add(desc);
            description = desc;
        }
        try {
            if (description != null) {
                mergeResult = dao.merge(description, true);
                result.addUpdatedObject(mergeResult.getMergedEntity());
            }
        // if (description instanceof SpecimenDescription){
        // result.addUpdatedObject(mergeResult.getMergedEntity().getDescribedSpecimenOrObservation());
        // }else if (description instanceof TaxonDescription){
        // result.addUpdatedObject(((TaxonDescription)mergeResult.getMergedEntity()).getTaxon());
        // }else if (description instanceof TaxonNameDescription){
        // result.addUpdatedObject(((TaxonNameDescription)mergeResult.getMergedEntity()).getTaxonName());
        // }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    return result;
}

Example 3 with QuantitativeDataDto

use of eu.etaxonomy.cdm.api.service.dto.QuantitativeDataDto in project cdmlib by cybertaxonomy.

the class DescriptionServiceImpl method loadDtos.

@Override
public List<DescriptionBaseDto> loadDtos(Set<UUID> descriptionUuids) {
    String sqlSelect = DescriptionBaseDto.getDescriptionBaseDtoSelect();
    Query query = getSession().createQuery(sqlSelect);
    query.setParameterList("uuid", descriptionUuids);
    @SuppressWarnings("unchecked") List<Object[]> result = query.list();
    List<DescriptionBaseDto> list = DescriptionBaseDto.descriptionBaseDtoListFrom(result);
    for (DescriptionBaseDto dto : list) {
        // get categorical data
        sqlSelect = CategoricalDataDto.getCategoricalDtoSelect();
        query = getSession().createQuery(sqlSelect);
        query.setParameter("uuid", dto.getDescriptionUuid());
        @SuppressWarnings("unchecked") List<Object[]> resultCat = query.list();
        List<CategoricalDataDto> listCategorical = CategoricalDataDto.categoricalDataDtoListFrom(resultCat);
        List<UUID> featureUuids = new ArrayList<>();
        for (CategoricalDataDto catDto : listCategorical) {
            featureUuids.add(catDto.getFeatureUuid());
        }
        Map<UUID, TermDto> featureDtos = termService.findFeatureByUUIDsAsDtos(featureUuids);
        for (CategoricalDataDto catDto : listCategorical) {
            FeatureDto featuredto = (FeatureDto) featureDtos.get(catDto.getFeatureUuid());
            catDto.setFeatureDto(featuredto);
        }
        dto.getElements().addAll(listCategorical);
        // get quantitative data
        sqlSelect = QuantitativeDataDto.getQuantitativeDataDtoSelect();
        query = getSession().createQuery(sqlSelect);
        query.setParameter("uuid", dto.getDescriptionUuid());
        @SuppressWarnings("unchecked") List<Object[]> resultQuant = query.list();
        List<QuantitativeDataDto> listQuant = QuantitativeDataDto.quantitativeDataDtoListFrom(resultQuant);
        dto.getElements().addAll(listQuant);
    }
    return list;
}

Example 4 with QuantitativeDataDto

use of eu.etaxonomy.cdm.api.service.dto.QuantitativeDataDto in project cdmlib by cybertaxonomy.

the class DescriptiveDataSetServiceTest method testAddQuantitativeData.

// the test currently does not run in suite due to exception during descriptionService.mergeDescriptions(descToUpdate, dataSet.getUuid());
@Ignore
@Test
@DataSets({ @DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class, value = "/eu/etaxonomy/cdm/database/ClearDB_with_Terms_DataSet.xml"), @DataSet(value = "/eu/etaxonomy/cdm/database/TermsDataSet-with_auditing_info.xml"), @DataSet(value = "StructuredDescriptionAggregationTest.xml") })
public void testAddQuantitativeData() {
    createDefaultFeatureTree();
    DescriptiveDataSet dataSet = createTestDataset();
    commitAndStartNewTransaction();
    List<RowWrapperDTO<?>> result = datasetService.getRowWrapper(dataSet.getUuid(), monitor);
    List<DescriptionBaseDto> descToUpdate = new ArrayList<>();
    UUID updatedDescription = null;
    int elementCount = 0;
    for (RowWrapperDTO<?> row : result) {
        if (row instanceof SpecimenRowWrapperDTO) {
            SpecimenRowWrapperDTO specimen = (SpecimenRowWrapperDTO) row;
            DescriptionBaseDto descDto = specimen.getDescription();
            elementCount = descDto.getElements().size();
            Feature feature = (Feature) termService.find(uuidFeatureLeafLength);
            QuantitativeDataDto quantDto = new QuantitativeDataDto(FeatureDto.fromFeature(feature));
            TermDto typeDto = new TermDto(StatisticalMeasure.EXACT_VALUE().getUuid(), null, StatisticalMeasure.EXACT_VALUE().getTermType(), StatisticalMeasure.EXACT_VALUE().getPartOf() != null ? StatisticalMeasure.EXACT_VALUE().getPartOf().getUuid() : null, StatisticalMeasure.EXACT_VALUE().getKindOf() != null ? StatisticalMeasure.EXACT_VALUE().getKindOf().getUuid() : null, StatisticalMeasure.EXACT_VALUE().getVocabulary() != null ? StatisticalMeasure.EXACT_VALUE().getVocabulary().getUuid() : null, null, StatisticalMeasure.EXACT_VALUE().getIdInVocabulary(), StatisticalMeasure.EXACT_VALUE().getTitleCache());
            StatisticalMeasurementValueDto statValue = new StatisticalMeasurementValueDto(typeDto, new BigDecimal("4.5"), null);
            Set<StatisticalMeasurementValueDto> values = new HashSet<>();
            values.add(statValue);
            quantDto.setValues(values);
            descDto.addElement(quantDto);
            descToUpdate.add(descDto);
            updatedDescription = descDto.getDescriptionUuid();
        }
    }
    commitAndStartNewTransaction();
    descriptionService.mergeDescriptions(descToUpdate, dataSet.getUuid());
    commitAndStartNewTransaction();
    DescriptionBase<?> description = descriptionService.load(updatedDescription);
    assertEquals(description.getElements().size(), elementCount + 1);
    for (Object el : description.getElements()) {
        if (el instanceof QuantitativeData) {
            QuantitativeData descEl = (QuantitativeData) el;
            if (descEl.getFeature().getUuid().equals(uuidFeatureLeafLength)) {
                assertEquals(descEl.getExactValues().size(), 1);
            }
        }
    }
}

Example 5 with QuantitativeDataDto

use of eu.etaxonomy.cdm.api.service.dto.QuantitativeDataDto in project cdmlib by cybertaxonomy.

the class DescriptionServiceImpl method loadDto.

@Override
public DescriptionBaseDto loadDto(UUID descriptionUuid) {
    String sqlSelect = DescriptionBaseDto.getDescriptionBaseDtoSelect();
    Query query = getSession().createQuery(sqlSelect);
    List<UUID> uuids = new ArrayList<UUID>();
    uuids.add(descriptionUuid);
    query.setParameterList("uuid", uuids);
    @SuppressWarnings("unchecked") List<Object[]> result = query.list();
    List<DescriptionBaseDto> list = DescriptionBaseDto.descriptionBaseDtoListFrom(result);
    if (list.size() == 1) {
        DescriptionBaseDto dto = list.get(0);
        // get categorical data
        sqlSelect = CategoricalDataDto.getCategoricalDtoSelect();
        query = getSession().createQuery(sqlSelect);
        query.setParameter("uuid", descriptionUuid);
        @SuppressWarnings("unchecked") List<Object[]> resultCat = query.list();
        List<CategoricalDataDto> listCategorical = CategoricalDataDto.categoricalDataDtoListFrom(resultCat);
        List<UUID> featureUuids = new ArrayList<>();
        for (CategoricalDataDto catDto : listCategorical) {
            featureUuids.add(catDto.getFeatureUuid());
        }
        Map<UUID, TermDto> featureDtos = termService.findFeatureByUUIDsAsDtos(featureUuids);
        for (CategoricalDataDto catDto : listCategorical) {
            FeatureDto featuredto = (FeatureDto) featureDtos.get(catDto.getFeatureUuid());
            catDto.setFeatureDto(featuredto);
        }
        dto.getElements().addAll(listCategorical);
        // get quantitative data
        sqlSelect = QuantitativeDataDto.getQuantitativeDataDtoSelect();
        query = getSession().createQuery(sqlSelect);
        query.setParameter("uuid", descriptionUuid);
        @SuppressWarnings("unchecked") List<Object[]> resultQuant = query.list();
        List<QuantitativeDataDto> listQuant = QuantitativeDataDto.quantitativeDataDtoListFrom(resultQuant);
        dto.getElements().addAll(listQuant);
        return dto;
    } else {
        return null;
    }
}