EDIT

import java.util.Collection;

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

    public List<UuidAndTitleCache<WorkingSet>> getWorkingSetUuidAndTitleCache(Integer limitOfInitialElements, String pattern);

    /**

     * Returns a collection of {@link RowWrapperDTO} objects for the given {@link WorkingSet}.<br>

     * A RowWrapper represents on row in the character matrix.

     * @param workingSet the working set for which the row wrapper objects should be fetched

     * @return a collection of row wrapper objects

     */

    public Collection<RowWrapperDTO> getRowWrapper(WorkingSet workingSet);

    /**

     * Loads all avaliable specimens wrapped in a {@link RowWrapperDTO} object for

     * a given {@link WorkingSet} according to the filters set in the working set

     * @param workingSet the working set for which the specimens should be fetched

     * @return a collection of wrapper objects containing the specimen

     */

    public Collection<RowWrapperDTO> loadSpecimens(WorkingSet workingSet);

import java.util.ArrayList;

import java.util.Collection;

import java.util.stream.Collectors;

import org.apache.log4j.Logger;

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

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

import eu.etaxonomy.cdm.filter.TaxonNodeFilter;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.occurrence.DerivedUnit;

import eu.etaxonomy.cdm.model.occurrence.FieldUnit;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.taxon.Taxon;

import eu.etaxonomy.cdm.model.taxon.TaxonBase;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

    private static Logger logger = Logger.getLogger(WorkingSetService.class);

    @Autowired

    private IOccurrenceService occurrenceService;

    @Autowired

    private ITaxonNodeService taxonNodeService;

	@Override

	public Collection<RowWrapperDTO> getRowWrapper(WorkingSet workingSet) {

	    return workingSet.getDescriptions().stream()

	            .map(description->createRowWrapper(null, description, workingSet))

	            .collect(Collectors.toList());

	}

    @Override

    public Collection<RowWrapperDTO> loadSpecimens(WorkingSet workingSet){

        List<RowWrapperDTO> specimenCache = new ArrayList<>();

        //set filter parameters

        TaxonNodeFilter filter = TaxonNodeFilter.NewRankInstance(workingSet.getMinRank(), workingSet.getMaxRank());

        workingSet.getGeoFilter().forEach(area -> filter.orArea(area.getUuid()));

        workingSet.getTaxonSubtreeFilter().forEach(node -> filter.orSubtree(node));

        filter.setIncludeUnpublished(true);

        List<UUID> filteredNodes = taxonNodeService.uuidList(filter);

        for (UUID uuid : filteredNodes) {

            //TODO implement occurrence service for taxon nodes

            // let it return UuidAndTitleCache

            TaxonNode taxonNode = taxonNodeService.load(uuid);

            Taxon taxon = taxonNode.getTaxon();

            if(taxon!=null){

                FindOccurrencesConfigurator config = new FindOccurrencesConfigurator();

                config.setAssociatedTaxonUuid(taxon.getUuid());

                List<SpecimenOrObservationBase> specimensForTaxon = occurrenceService.findByTitle(config).getRecords();

                specimensForTaxon.forEach(specimen -> specimenCache.add(createRowWrapper(specimen, null, workingSet)));

            }

        }

        return specimenCache;

    }

	private RowWrapperDTO createRowWrapper(SpecimenOrObservationBase specimen, DescriptionBase description, WorkingSet workingSet){

	    if(description!=null){

	        specimen = description.getDescribedSpecimenOrObservation();

	    }

        TaxonNode taxonNode = null;

        FieldUnit fieldUnit = null;

        String identifier = null;

        NamedArea country = null;

        //supplemental information

        if(specimen!=null){

            Collection<TaxonBase<?>> associatedTaxa = occurrenceService.listAssociatedTaxa(specimen, null, null, null, null);

            if(associatedTaxa!=null){

                //FIXME: what about multiple associated taxa

                Set<TaxonNode> taxonSubtreeFilter = workingSet.getTaxonSubtreeFilter();

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

                    taxonNode = ((Taxon) associatedTaxa.iterator().next()).getTaxonNode(taxonSubtreeFilter.iterator().next().getClassification());

                }

            }

            Collection<FieldUnit> fieldUnits = occurrenceService.getFieldUnits(specimen.getUuid());

            if(fieldUnits.size()!=1){

                logger.error("More than one or no field unit found for specimen"); //$NON-NLS-1$

            }

            else{

                fieldUnit = fieldUnits.iterator().next();

            }

            if(specimen instanceof DerivedUnit){

                identifier = occurrenceService.getMostSignificantIdentifier(HibernateProxyHelper.deproxy(specimen, DerivedUnit.class));

            }

            if(fieldUnit!=null && fieldUnit.getGatheringEvent()!=null){

                country = fieldUnit.getGatheringEvent().getCountry();

            }

        }

        return new RowWrapperDTO(description, taxonNode, fieldUnit, identifier, country);

	}

// $Id$

/**

* Copyright (C) 2018 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.api.service.dto;

import java.io.Serializable;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import java.util.Set;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.location.NamedArea;

import eu.etaxonomy.cdm.model.occurrence.FieldUnit;

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

/**

 * @author pplitzner

 * @date 16.04.2018

 *

 */

public class RowWrapperDTO implements Serializable {

    private static final long serialVersionUID = -7817164423660563673L;

    private DescriptionBase description;

    private SpecimenOrObservationBase specimen;

    private TaxonNode taxonNode;

    private FieldUnit fieldUnit;

    private String identifier;

    private NamedArea country;

    private Map<Feature, DescriptionElementBase> featureToElementMap;

    public RowWrapperDTO(DescriptionBase description, TaxonNode taxonNode, FieldUnit fieldUnit, String identifier,

            NamedArea country) {

        this.taxonNode = taxonNode;

        this.fieldUnit = fieldUnit;

        this.identifier = identifier;

        this.country = country;

        this.featureToElementMap = new HashMap<>();

        if(description!=null){

            setDescription(description);

        }

    }

    public QuantitativeData addQuantitativeData(Feature feature){

        QuantitativeData data = QuantitativeData.NewInstance(feature);

        description.addElement(data);

        featureToElementMap.put(feature, data);

        return data;

    }

    public CategoricalData addCategoricalData(Feature feature){

        CategoricalData data = CategoricalData.NewInstance(feature);

        description.addElement(data);

        featureToElementMap.put(feature, data);

        return data;

    }

    public DescriptionBase getSpecimenDescription() {

        return description;

    }

    public SpecimenOrObservationBase getSpecimen() {

        return specimen;

    }

    public TaxonNode getTaxonNode() {

        return taxonNode;

    }

    public FieldUnit getFieldUnit() {

        return fieldUnit;

    }

    public String getIdentifier() {

        return identifier;

    }

    public NamedArea getCountry() {

        return country;

    }

    public void setDescription(DescriptionBase description) {

        this.description = description;

        this.specimen = description.getDescribedSpecimenOrObservation();

        Set<DescriptionElementBase> elements = description.getElements();

        for (DescriptionElementBase descriptionElementBase : elements) {

            Feature feature = descriptionElementBase.getFeature();

            featureToElementMap.put(feature, descriptionElementBase);

        }

    }

    public Object getDataValueForFeature(Feature feature){

        DescriptionElementBase descriptionElementBase = featureToElementMap.get(feature);

        return descriptionElementBase;

    }

    public void setDataValueForFeature(Feature feature, Object newValue){

        /* Only CategoricalData is handled here because for QuantitativeData the value

         * is set in the ModifyListener of the swt.Text in the CellEditor

         * for each StatisticalMeasure. So no need to set it again here.

         */

        DescriptionElementBase descriptionElementBase = featureToElementMap.get(feature);

        if(descriptionElementBase!=null && descriptionElementBase.isInstanceOf(CategoricalData.class) && newValue instanceof Collection){

            CategoricalData categoricalData = HibernateProxyHelper.deproxy(descriptionElementBase, CategoricalData.class);

            categoricalData.setStateDataOnly(new ArrayList<>((Collection<State>) newValue));

        }

    }

}