EDIT

import java.util.HashSet;

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

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

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

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

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

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

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

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

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

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

        MergeResult<TermNode> mergeResult;

//        Iterator<TermNodeDto> dtoIterator = dtos.iterator();

            for (TermNodeDto dto: dtos){

    //            TermNodeDto dto = dtoIterator.next();

                if (dto.getUuid().equals(node.getUuid())){

    //                only node changes, everything else will be handled by the operations/service methods

                    if (!dto.getInapplicableIf().equals(node.getInapplicableIf())){

                        node.getInapplicableIf().clear();

                        node.getInapplicableIf().addAll(dto.getInapplicableIf());

                    }

                    if (!dto.getOnlyApplicableIf().equals(node.getOnlyApplicableIf())){

                        node.getOnlyApplicableIf().clear();

                        node.getOnlyApplicableIf().addAll(dto.getOnlyApplicableIf());

                    }

                mergeResult = dao.merge(node, true);

                result.addUpdatedObject(mergeResult.getMergedEntity());

            }

        }

        //saveOrUpdate all nodes

        return result;

    }

    @Override

    public UpdateResult saveCharacterNodeDtoList(List<CharacterNodeDto> dtos){

        MergeResult<TermNode> mergeResult;

        UpdateResult result = new UpdateResult();

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

        dtos.stream().forEach(dto -> nodeUuids.add(dto.getUuid()));

        List<TermNode> nodes = dao.list(nodeUuids, null, 0, null, null);

        //check all attributes for changes and adapt

        Iterator<CharacterNodeDto> dtoIterator = dtos.iterator();

        for (TermNode<Character> node: nodes){

            for (CharacterNodeDto dto: dtos){

    //            TermNodeDto dto = dtoIterator.next();

                if (dto.getUuid().equals(node.getUuid())){

    //                only node changes, everything else will be handled by the operations/service methods

                    if (!dto.getInapplicableIf().equals(node.getInapplicableIf())){

                        node.getInapplicableIf().clear();

                        node.getInapplicableIf().addAll(dto.getInapplicableIf());

                    }

                    if (!dto.getOnlyApplicableIf().equals(node.getOnlyApplicableIf())){

                        node.getOnlyApplicableIf().clear();

                        node.getOnlyApplicableIf().addAll(dto.getOnlyApplicableIf());

                    }

                    Character character = null;

                    CharacterDto characterDto = (CharacterDto) dto.getTerm();

                    character = HibernateProxyHelper.deproxy(node.getTerm(), Character.class);

//                  representations

                    for (Representation rep: dto.getTerm().getRepresentations()){

                        Representation oldRep = character.getRepresentation(rep.getLanguage());

                        if (oldRep == null){

                            oldRep = new Representation();

                            oldRep.setLanguage(rep.getLanguage());

                            character.addRepresentation(oldRep);

                        }

                        oldRep.setLabel(rep.getLabel());

                        oldRep.setAbbreviatedLabel(rep.getAbbreviatedLabel());

                        oldRep.setText(rep.getText());

                    }

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

                    if (character.getRepresentations().size() > dto.getTerm().getRepresentations().size()){

                        for (Representation rep: character.getRepresentations()){

                            if(dto.getTerm().getRepresentation(rep.getLanguage()) == null){

                                deleteRepresentations.add(rep);

                            }

                        }

                    }

                    if (!deleteRepresentations.isEmpty()){

                        for (Representation rep: deleteRepresentations){

                            character.removeRepresentation(rep);

                        }

                    }

//                  structural modifier

                    if (characterDto.getStructureModifier() != null){

                        DefinedTerm structureModifier = (DefinedTerm) termService.load(characterDto.getStructureModifier().getUuid());

                        character.setStructureModifier(structureModifier);

                    }

//                  supports quantitative data

                    character.setSupportsQuantitativeData(characterDto.isSupportsQuantitativeData());

//                  recommended measurement units

                    character.getRecommendedMeasurementUnits().clear();

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

                    for (TermDto termDto: characterDto.getRecommendedMeasurementUnits()){

                        uuids.add(termDto.getUuid());

                    }

                    List<DefinedTermBase> terms;

                    if (!uuids.isEmpty()){

                        terms = termService.load(uuids, null);

                        Set<MeasurementUnit> measurementUnits = new HashSet<>();

                        for (DefinedTermBase term: terms){

                            if (term instanceof MeasurementUnit){

                                measurementUnits.add((MeasurementUnit)term);

                            }

                        }

                        character.getRecommendedMeasurementUnits().addAll(measurementUnits);

                    }

//                  statistical measures

                    character.getRecommendedStatisticalMeasures().clear();

                    uuids = new ArrayList<>();

                    for (TermDto termDto: characterDto.getRecommendedStatisticalMeasures()){

                        uuids.add(termDto.getUuid());

                    }

                    if (!uuids.isEmpty()){

                        terms = termService.load(uuids, null);

                        Set<StatisticalMeasure> statisticalMeasures = new HashSet<>();

                        for (DefinedTermBase term: terms){

                            if (term instanceof StatisticalMeasure){

                                statisticalMeasures.add((StatisticalMeasure)term);

                            }

                        }

                        character.getRecommendedStatisticalMeasures().addAll(statisticalMeasures);

                    }

//                  recommended mod. vocabularies

                    character.getRecommendedModifierEnumeration().clear();

                    uuids = new ArrayList<>();

                    for (TermVocabularyDto termDto: characterDto.getRecommendedModifierEnumeration()){

                        uuids.add(termDto.getUuid());

                    }

                    List<TermVocabulary> termVocs;

                    if (!uuids.isEmpty()){

                        termVocs = vocabularyService.load(uuids, null);

                        for (TermVocabulary voc: termVocs){

                            character.addRecommendedModifierEnumeration(voc);

                        }

                    }

//                  supports categorical data

                    character.setSupportsCategoricalData(characterDto.isSupportsCategoricalData());

//                  supported state vocabularies

                    character.getSupportedCategoricalEnumerations().clear();

                    uuids = new ArrayList<>();

                    for (TermVocabularyDto termDto: characterDto.getSupportedCategoricalEnumerations()){

                        uuids.add(termDto.getUuid());

                    }

                    if (!uuids.isEmpty()){

                        termVocs = vocabularyService.load(uuids, null);

                        for (TermVocabulary voc: termVocs){

                            character.addSupportedCategoricalEnumeration(voc);

                        }

                    }

                    node.setTerm(character);

                    UUID uuid = dao.saveOrUpdate(node);

                    result.addUpdatedObject(load(uuid));

//                    result.addUpdatedObject(termService.merge(character, true).getMergedEntity());