EDIT

import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;

import eu.etaxonomy.cdm.api.service.config.SpecimenDeleteConfigurator;

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

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

import eu.etaxonomy.cdm.api.service.dto.DerivateDataDTO.ContigFile;

import eu.etaxonomy.cdm.api.service.dto.DerivateDataDTO.Link;

import eu.etaxonomy.cdm.api.service.dto.DerivateDataDTO.MolecularData;

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

import eu.etaxonomy.cdm.api.service.exception.ReferencedObjectUndeletableException;

import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;

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

                    collectionToCountMap.put(collection, herbariumCount + 1);

                }

                if (derivedUnit.getRecordBasis().equals(SpecimenOrObservationType.PreservedSpecimen)) {

                    fieldUnitDTO.addDerivate(preservedSpecimenDTO);

                    fieldUnitDTO.setHasCharacterData(fieldUnitDTO.isHasCharacterData() || preservedSpecimenDTO.isHasCharacterData());

                    fieldUnitDTO.setHasDetailImage(fieldUnitDTO.isHasDetailImage() || preservedSpecimenDTO.isHasDetailImage());

    }

    @Override

        return assemblePreservedSpecimenDTO(derivedUnit, null);

    }

        return null;

    }

        if (!getSession().contains(derivedUnit)) {

            derivedUnit = (DerivedUnit) load(derivedUnit.getUuid());

        }

        //specimen identifier

        FormatKey collectionKey = FormatKey.COLLECTION_CODE;

        return preservedSpecimenDTO;

    }

        DerivateDataDTO derivateDataDTO = new DerivateDataDTO();

        Collection<DerivedUnit> childDerivates = getDerivedUnitsFor(specimenOrObservation);

        for (DerivedUnit childDerivate : childDerivates) {

                        derivateDataDTO.addSpecimenScanUuid(media.getMediaSpecimen().getUuid());

                        derivateDTO.setHasSpecimenScan(true);

                        String imageLinkText = "scan";

                        }

                        derivateDataDTO.addSpecimenScan(mediaUri, imageLinkText);

                    }

        return derivedUnits;

    }

//        load

        for (DerivationEvent derivationEvent : specimen.getDerivationEvents()) {

            for (DerivedUnit derivative : derivationEvent.getDerivatives()) {

                if (!alreadyCollectedSpecimen.containsKey(specimenDto.getUuid())){

                    if (derivative instanceof DnaSample) {

                        dto = new DNASampleDTO(derivative);

                    } else {

                    }

                    alreadyCollectedSpecimen.put(dto.getUuid(), dto);

                    dto.addAllDerivates(getDerivedUnitDTOsFor(dto, derivative, alreadyCollectedSpecimen));

        Set<Taxon> taxa = new HashSet<>();

        Set<Integer> occurrenceIds = new HashSet<>();

        List<FieldUnitDTO> fieldUnitDTOs = new ArrayList<>();

        List<SpecimenOrObservationBase> occurrences = new ArrayList<>();

        boolean includeUnpublished = INCLUDE_UNPUBLISHED;

            for (SpecimenOrObservationBase<?> o : perTaxonOccurrences) {

                if (o.isInstanceOf(DerivedUnit.class)){

                    DerivedUnit derivedUnit;

                    if (o.isInstanceOf(DnaSample.class)) {

                         derivedUnit = HibernateProxyHelper.deproxy(o, DnaSample.class);

                        derivedUnitDTO = new DNASampleDTO(derivedUnit);

                    } else {

                        derivedUnit = HibernateProxyHelper.deproxy(o, DerivedUnit.class);

                    }

                    if (alreadyCollectedSpecimen.get(derivedUnitDTO.getUuid()) == null){

                        alreadyCollectedSpecimen.put(derivedUnitDTO.getUuid(), derivedUnitDTO);

            List<String> propertyPaths)  {

        DnaSample dnaSample = dao.findByGeneticAccessionNumber(accessionNumberString, propertyPaths);

        List<FieldUnitDTO> fieldUnitDTOs = new ArrayList<>();

        if (dnaSample != null){

            derivedUnitDTO = new DNASampleDTO(dnaSample);

    @Override

    @Transactional(readOnly=true)

        //It will search recursively over all {@link DerivationEvent}s and get the "originals" ({@link SpecimenOrObservationBase})

        //from which this DerivedUnit was derived until all FieldUnits are found.

        List<SpecimenOrObservationBase> specimens = new ArrayList<>();

                fieldUnits.add(fieldUnitDto);

            }else{

                if (specimen instanceof DnaSample){

                    originalDTO = new DNASampleDTO((DnaSample)specimen);

                } else {

                }

                originalDTO.addDerivate(derivedUnitDTO);

                fieldUnitDto = findFieldUnitDTO(originalDTO, fieldUnits,

    public FieldUnitDTO loadFieldUnitDTO(UUID derivedUnitUuid) {

        FieldUnitDTO fieldUnitDTO = null;

        SpecimenOrObservationBase derivative = dao.load(derivedUnitUuid);

        if(derivative != null){

            if (derivative instanceof FieldUnit){

                return fieldUnitDTO;

            } else {

                // must be a DerivedUnit otherwise

                while(true){

                    if(originals.isEmpty()){

                        break;

                        logger.debug("The derived unit with uuid " + derivedUnitUuid + "has more than one orginal, ignoring all but the first one.");

                    }

                    // cycle detection and handling

                    if(cycleDetectionMap.containsKey(originalDTO.getUuid())){

                        // to solve the situation for the output we remove the derivate from the more distant graph node

                        // by removing it from the derivatives of its original

                        // but let the derivate to be added to the original which is closer to the FieldUnit (below at originalDTO.addDerivate(derivedUnitDTO);)

                                if(derivateDTO.equals(originalDTO)){

                                    seenOriginal.getDerivates().remove(originalDTO);

                                }

     * @param originalDTO

     * @return

     */

        List<SpecimenOrObservationBase> specimens = dao.findOriginalsForDerivedUnit(derivativeUuid, null);

        for(SpecimenOrObservationBase sob : specimens){

            if(sob instanceof FieldUnit) {

                dtos.add(FieldUnitDTO.fromEntity((FieldUnit)sob));

            } else {

            }

        }

        return dtos;

    }

    @Override

        Taxon taxon = null;

        if(config.getAssociatedTaxonUuid()!=null){

            TaxonBase<?> taxonBase = taxonService.load(config.getAssociatedTaxonUuid());

                config.getSpecimenType(), taxon, taxonName, config.getMatchMode(), null, null,

                config.getOrderHints(), null));

        occurrences.forEach(derivedUnit->dtos.add(assemblePreservedSpecimenDTO(derivedUnit)));

        return dtos;

    }