Examples with CategoricalData eu.etaxonomy.cdm.model.description.CategoricalData used on opensource projects

Example 1 with CategoricalData

use of eu.etaxonomy.cdm.model.description.CategoricalData in project cdmlib by cybertaxonomy.

the class CsvDemoExport method handleRedlistStatus.

/**
 * @param record
 * @param taxon
 * @param featureCells
 * @param features
 */
private void handleRedlistStatus(CsvDemoRecord record, Taxon taxon, List<List<String>> featureCells, List<Feature> features) {
    Set<TaxonDescription> descriptions = taxon.getDescriptions();
    for (TaxonDescription description : descriptions) {
        for (DescriptionElementBase el : description.getElements()) {
            if (el.isInstanceOf(CategoricalData.class)) {
                CategoricalData categoricalData = CdmBase.deproxy(el, CategoricalData.class);
                for (State state : categoricalData.getStatesOnly()) {
                    Feature stateFeature = categoricalData.getFeature();
                    // find matching feature and put data into according cell
                    for (int i = 0; i < features.size(); i++) {
                        if (features.get(i).equals(stateFeature)) {
                            List<String> cell = featureCells.get(i);
                            cell.add(state.toString());
                        }
                    }
                }
            } else if (el.isInstanceOf(TextData.class)) {
                TextData textData = CdmBase.deproxy(el, TextData.class);
                Feature textFeature = textData.getFeature();
                // find matching feature and put data into according cell
                for (int i = 0; i < features.size(); i++) {
                    if (features.get(i).equals(textFeature)) {
                        List<String> cell = featureCells.get(i);
                        String text = textData.getText(Language.GERMAN());
                        text = text.replaceAll(System.getProperty("line.separator"), "");
                        text = text.replaceAll("                            ", " ");
                        cell.add(text);
                    }
                }
            }
        }
    }
    record.setFeatures(featureCells);
}

Example 2 with CategoricalData

use of eu.etaxonomy.cdm.model.description.CategoricalData in project cdmlib by cybertaxonomy.

the class DescriptionElementDaoHibernateImplTest method testSaveCategoricalData.

// test cascading for modifying text (and others)
@Test
@DataSet(loadStrategy = CleanSweepInsertLoadStrategy.class)
@ExpectedDataSet(factory = MultiSchemaXmlDataSetFactory.class)
public void testSaveCategoricalData() {
    UUID uuidDummyState = UUID.fromString("881b9c80-626d-47a6-b308-a63ee5f4178f");
    State state = (State) termDao.findByUuid(uuidDummyState);
    CategoricalData categoricalData = CategoricalData.NewInstance();
    categoricalData.setUuid(UUID.fromString("5c3f2340-f675-4d50-af96-89a2a12993b8"));
    categoricalData.setFeature(Feature.DESCRIPTION());
    StateData stateData = StateData.NewInstance(state);
    stateData.setUuid(UUID.fromString("04b9190d-d4ab-4c3a-8dec-8293dc820ddc"));
    stateData.putModifyingText(Language.ENGLISH(), "test modifier");
    LanguageString langString = stateData.getModifyingText().get(Language.ENGLISH());
    langString.setUuid(UUID.fromString("53a91bd4-d758-47ec-a385-94799bdb9f32"));
    categoricalData.addStateData(stateData);
    DefinedTerm modifier = DefinedTerm.SEX_FEMALE();
    System.out.println(modifier.getId());
    stateData.addModifier(modifier);
    descriptionElementDao.save(categoricalData);
    commit();
// commitAndStartNewTransaction(new String[]{"Hibernate_sequences","DescriptionElementBase","DescriptionElementBase_StateData","StateData_DefinedTermBase", "StateData", "StateData_LanguageString", "LanguageString"});
}

Example 3 with CategoricalData

use of eu.etaxonomy.cdm.model.description.CategoricalData 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 4 with CategoricalData

use of eu.etaxonomy.cdm.model.description.CategoricalData in project cdmlib by cybertaxonomy.

the class DescriptiveDataSetService method findSpecimenDescription.

@Override
@Transactional(readOnly = false)
public DescriptionBaseDto findSpecimenDescription(UUID descriptiveDataSetUuid, SpecimenOrObservationBase specimen) {
    DescriptiveDataSetBaseDto dataSet = this.getDescriptiveDataSetDtoByUuid(descriptiveDataSetUuid);
    // SpecimenOrObservationBase specimen = occurrenceService.load(specimenUuid);
    TermTreeDto datasetFeatures = dataSet.getDescriptiveSystem();
    List<DescriptionElementBase> matchingDescriptionElements = new ArrayList<>();
    for (SpecimenDescription specimenDescription : (Set<SpecimenDescription>) specimen.getDescriptions()) {
        specimenDescription = (SpecimenDescription) descriptionService.load(specimenDescription.getUuid());
        // check if description is already added to data set
        if (dataSet.getDescriptionUuids().contains(specimenDescription.getUuid())) {
            return DescriptionBaseDto.fromDescription(specimenDescription);
        }
        // gather specimen description features and check for match with dataset features
        Set<Feature> specimenDescriptionFeatures = new HashSet<>();
        for (DescriptionElementBase specimenDescriptionElement : specimenDescription.getElements()) {
            Feature feature = specimenDescriptionElement.getFeature();
            specimenDescriptionFeatures.add(feature);
            boolean contains = false;
            for (TermDto featureDto : datasetFeatures.getTerms()) {
                if (featureDto.getUuid().equals(feature.getUuid())) {
                    contains = true;
                    break;
                }
            }
            if (contains && RowWrapperDTO.hasData(specimenDescriptionElement)) {
                matchingDescriptionElements.add(specimenDescriptionElement);
            }
        }
    }
    // Create new specimen description if description has not already been added to the dataset
    SpecimenDescription newDesription = SpecimenDescription.NewInstance(specimen);
    // $NON-NLS-2$
    newDesription.setTitleCache("Dataset " + dataSet.getTitleCache() + ": " + newDesription.generateTitle(), true);
    // check for equals description element (same feature and same values)
    Map<Feature, List<DescriptionElementBase>> featureToElementMap = new HashMap<>();
    for (DescriptionElementBase element : matchingDescriptionElements) {
        List<DescriptionElementBase> list = featureToElementMap.get(element.getFeature());
        if (list == null) {
            list = new ArrayList<>();
        }
        list.add(element);
        featureToElementMap.put(element.getFeature(), list);
    }
    Set<DescriptionElementBase> descriptionElementsToClone = new HashSet<>();
    for (Feature feature : featureToElementMap.keySet()) {
        List<DescriptionElementBase> elements = featureToElementMap.get(feature);
        // no duplicate description elements found for this feature
        if (elements.size() == 1) {
            descriptionElementsToClone.add(elements.get(0));
        } else // duplicates found -> check if all are equal
        {
            DescriptionElementBase match = null;
            for (DescriptionElementBase descriptionElementBase : elements) {
                if (match == null) {
                    match = descriptionElementBase;
                } else if (!new DescriptionElementCompareWrapper(match).equals(new DescriptionElementCompareWrapper(descriptionElementBase))) {
                    match = null;
                    // String.format(Messages.CharacterMatrix_MULTIPLE_DATA_MESSAGE, feature.getLabel()));
                    break;
                }
            }
            if (match != null) {
                descriptionElementsToClone.add(match);
            }
        }
    }
    // clone matching descriptionElements
    for (DescriptionElementBase descriptionElementBase : descriptionElementsToClone) {
        DescriptionElementBase clone;
        clone = descriptionElementBase.clone(newDesription);
        clone.getSources().forEach(source -> {
            if (descriptionElementBase instanceof CategoricalData) {
                TextData label = new DefaultCategoricalDescriptionBuilder().build((CategoricalData) descriptionElementBase, Arrays.asList(new Language[] { Language.DEFAULT() }));
                source.setOriginalNameString(label.getText(Language.DEFAULT()));
            } else if (descriptionElementBase instanceof QuantitativeData) {
                TextData label = new DefaultQuantitativeDescriptionBuilder().build((QuantitativeData) descriptionElementBase, Arrays.asList(new Language[] { Language.DEFAULT() }));
                source.setOriginalNameString(label.getText(Language.DEFAULT()));
            }
        });
    }
    // }
    return DescriptionBaseDto.fromDescription(newDesription);
}

Example 5 with CategoricalData

use of eu.etaxonomy.cdm.model.description.CategoricalData 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;
}