EDIT

      <mapping class="eu.etaxonomy.cdm.model.description.WorkingSet"/>

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

	private WorkingSet workingSet = null;

		workingSet.addRepresentation(representation);

		workingSet = WorkingSet.NewInstance();

		getWorkingSetService().save(workingSet);

			workingSet.addDescription(taxonDescription);

					if (workingSet.getDescriptiveSystem() != null){

						workingSet.setDescriptiveSystem(featureTree);

  <WORKINGSET/>

  <WORKINGSET_ANNOTATION/>

  <WORKINGSET_ANNOTATION_AUD/>

  <WORKINGSET_AUD/>

  <WORKINGSET_DESCRIPTIONBASE/>

  <WORKINGSET_DESCRIPTIONBASE_AUD/>

  <WORKINGSET_MARKER/>

  <WORKINGSET_MARKER_AUD/>

  <WORKINGSET_REPRESENTATION/>

  <WORKINGSET_REPRESENTATION_AUD/>

<WORKINGSET/>

<WORKINGSET_ANNOTATION/>

<WORKINGSET_ANNOTATION_AUD/>

<WORKINGSET_AUD/>

<WORKINGSET_DESCRIPTIONBASE/>

<WORKINGSET_DESCRIPTIONBASE_AUD/>

<WORKINGSET_MARKER/>

<WORKINGSET_MARKER_AUD/>

<WORKINGSET_REPRESENTATION/>

<WORKINGSET_REPRESENTATION_AUD/>

  <HIBERNATE_SEQUENCES SEQUENCE_NAME="WorkingSet" NEXT_VAL="3001"/>

        @MetaValue(value = "WorkingSet", targetEntity = WorkingSet.class),

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

    "workingSets",

    @XmlElementWrapper(name = "WorkingSets")

    @XmlElement(name = "WorkingSet")

    private Set<WorkingSet> workingSets = new HashSet<WorkingSet>();

    public Set<WorkingSet> getWorkingSets() {

        return workingSets;

    public boolean addWorkingSet(WorkingSet workingSet){

        boolean result = this.workingSets.add(workingSet);

        if (! workingSet.getDescriptions().contains(this)){

            workingSet.addDescription(this);

    public boolean removeWorkingSet(WorkingSet workingSet){

        boolean result = this.workingSets.remove(workingSet);

        if (workingSet.getDescriptions().contains(this)){

            workingSet.addDescription(this);

    protected void setWorkingSets(Set<WorkingSet> workingSets) {

        this.workingSets = workingSets;

            result.workingSets = new HashSet<WorkingSet>();

            for (WorkingSet workingSet : getWorkingSets()){

                workingSet.addDescription(result);

//@Indexed(index = "eu.etaxonomy.cdm.model.media.WorkingSet")

public class MultiAccessKey extends WorkingSet implements IIdentificationKey{

/**

* Copyright (C) 2007 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.model.description;

import java.util.HashSet;

import java.util.Iterator;

import java.util.List;

import java.util.Set;

import javax.persistence.Entity;

import javax.persistence.FetchType;

import javax.persistence.JoinTable;

import javax.persistence.ManyToMany;

import javax.persistence.ManyToOne;

import javax.persistence.OneToMany;

import javax.persistence.Transient;

import javax.validation.constraints.NotNull;

import javax.xml.bind.annotation.XmlAccessType;

import javax.xml.bind.annotation.XmlAccessorType;

import javax.xml.bind.annotation.XmlElement;

import javax.xml.bind.annotation.XmlElementWrapper;

import javax.xml.bind.annotation.XmlIDREF;

import javax.xml.bind.annotation.XmlRootElement;

import javax.xml.bind.annotation.XmlSchemaType;

import javax.xml.bind.annotation.XmlType;

import org.apache.log4j.Logger;

import org.hibernate.annotations.Cascade;

import org.hibernate.annotations.CascadeType;

import org.hibernate.envers.Audited;

import eu.etaxonomy.cdm.model.common.IdentifiableEntity;

import eu.etaxonomy.cdm.model.common.Language;

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

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

import eu.etaxonomy.cdm.model.name.Rank;

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

import eu.etaxonomy.cdm.strategy.cache.description.WorkingSetDefaultCacheStrategy;

/**

 *

 * The working set class allows the demarcation of a set of descriptions

 * associated with representations and a set of features and their

 * dependencies.

 *

 * @author h.fradin

 * @since 12.08.2009

 */

@XmlAccessorType(XmlAccessType.FIELD)

@XmlType(name = "WorkingSet", propOrder = {

    "representations",

    "descriptiveSystem",

    "descriptions",

    "taxonSubtreeFilter",

    "geoFilter",

    "minRank",

    "maxRank"

})

@XmlRootElement(name = "WorkingSet")

@Entity

@Audited

public class WorkingSet extends IdentifiableEntity<WorkingSetDefaultCacheStrategy> {

	private static final long serialVersionUID = 3256448866757415686L;

	private static final Logger logger = Logger.getLogger(WorkingSet.class);

	@XmlElementWrapper(name = "Representations")

	@XmlElement(name = "Representation")

    @OneToMany(fetch=FetchType.EAGER)

	@Cascade( { CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE })

	private Set<Representation> representations = new HashSet<>();

	@XmlElement(name = "DescriptiveSystem")

	@XmlIDREF

	@XmlSchemaType(name = "IDREF")

	@ManyToOne(fetch = FetchType.LAZY)

	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

	private FeatureTree descriptiveSystem;

	@XmlElementWrapper(name = "Descriptions")

	@XmlElement(name = "Description")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToMany(fetch = FetchType.LAZY)

	@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

	@NotNull

	private Set<DescriptionBase> descriptions = new HashSet<>();

    @XmlElementWrapper(name = "SubtreeTaxonFilter")

    @XmlElement(name = "Subtree")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToMany(fetch = FetchType.LAZY)

    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

    @NotNull

    //a positive filter that defines that all taxa in the subtree belong to

    //the dataset. If the filter is NOT set, taxa need to be explicitly defined

    //via the descriptions set. If the filter is set all taxa not having

    //a description in descriptions yet are considered to have an empty description

    //TODO what, if a taxon is removed from the subtree but a description exists in

    //descriptions

    private Set<TaxonNode> taxonSubtreeFilter = new HashSet<>();

    @XmlElementWrapper(name = "GeoFilter")

    @XmlElement(name = "FilteredArea")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToMany(fetch = FetchType.LAZY)

    @Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})

    @JoinTable(name="WorkingSet_NamedArea")

    @NotNull

    private Set<NamedArea> geoFilter = new HashSet<>();

    @XmlElement(name = "minRank")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

    private Rank minRank;

    @XmlElement(name = "maxRank")

    @XmlIDREF

    @XmlSchemaType(name = "IDREF")

    @ManyToOne(fetch = FetchType.LAZY)

    private Rank maxRank;

// ******************* FACTORY *********************************************/

	public static WorkingSet NewInstance(){

        return new WorkingSet();

    }

// *******************CONSTRUCTOR **********************************/

	/**

	 * Class constructor: creates a new empty working set instance.

	 */

	protected WorkingSet() {

		super();

		this.cacheStrategy = new WorkingSetDefaultCacheStrategy();

	}

// ******************** GETTER / SETTER ************************/

	public Set<TaxonNode> getTaxonSubtreeFilter() {

        return taxonSubtreeFilter;

    }

    public void setTaxonSubtreeFilter(Set<TaxonNode> taxonSubtreeFilter) {

        this.taxonSubtreeFilter = taxonSubtreeFilter;

    }

    public void  addTaxonSubtree(TaxonNode subtree) {

        this.taxonSubtreeFilter.add(subtree);

    }

    public void  removeTaxonSubtree(TaxonNode subtree) {

        this.taxonSubtreeFilter.remove(subtree);

    }

    //geo filter

    public Set<NamedArea> getGeoFilter() {

        return geoFilter;

    }

    public void setGeoFilter(Set<NamedArea> geoFilter) {

        this.geoFilter = geoFilter;

    }

    public void addGeoFilterArea(NamedArea area){

        this.geoFilter.add(area);

    }

    public boolean removeGeoFilterArea(NamedArea area) {

        return this.geoFilter.remove(area);

    }

    //min rank

    public Rank getMinRank() {

        return minRank;

    }

    public void setMinRank(Rank minRank) {

        this.minRank = minRank;

    }

    //max rank

    public Rank getMaxRank() {

        return maxRank;

    }

    public void setMaxRank(Rank maxRank) {

        this.maxRank = maxRank;

    }

    //representations

	public Set<Representation> getRepresentations() {

		return this.representations;

	}

	public void addRepresentation(Representation representation) {

		this.representations.add(representation);

	}

	public void removeRepresentation(Representation representation) {

		this.representations.remove(representation);

	}

	public Representation getRepresentation(Language lang) {

		for (Representation repr : representations){

			Language reprLanguage = repr.getLanguage();

			if (reprLanguage != null && reprLanguage.equals(lang)){

				return repr;

			}

		}

		return null;

	}

	/**

	 * @see #getPreferredRepresentation(Language)

	 * @param language

	 * @return

	 */

	public Representation getPreferredRepresentation(Language language) {

		Representation repr = getRepresentation(language);

		if(repr == null){

			repr = getRepresentation(Language.DEFAULT());

		}

		if(repr == null){

			repr = getRepresentations().iterator().next();

		}

		return repr;

	}

	/**

	 * Returns the Representation in the preferred language. Preferred languages

	 * are specified by the parameter languages, which receives a list of

	 * Language instances in the order of preference. If no representation in

	 * any preferred languages is found the method falls back to return the

	 * Representation in Language.DEFAULT() and if necessary further falls back

	 * to return the first element found if any.

	 *

	 * TODO think about this fall-back strategy &

	 * see also {@link TextData#getPreferredLanguageString(List)}

	 *

	 * @param languages

	 * @return

	 */

	public Representation getPreferredRepresentation(List<Language> languages) {

		Representation repr = null;

		if(languages != null){

			for(Language language : languages) {

				repr = getRepresentation(language);

				if(repr != null){

					return repr;

				}

			}

		}

		if(repr == null){

			repr = getRepresentation(Language.DEFAULT());

		}

		if(repr == null){

			Iterator<Representation> it = getRepresentations().iterator();

			if(it.hasNext()){

				repr = getRepresentations().iterator().next();

			}

		}

		return repr;

	}

	@Transient

	public String getLabel() {

		if(getLabel(Language.DEFAULT())!=null){

			Representation repr = getRepresentation(Language.DEFAULT());

			return (repr == null)? null :repr.getLabel();

		}else{

			for (Representation r : representations){

				return r.getLabel();

			}

		}

		return super.getUuid().toString();

	}

	public String getLabel(Language lang) {

		Representation repr = this.getRepresentation(lang);

		return (repr == null) ? null : repr.getLabel();

	}

	public void setLabel(String label){

		Language lang = Language.DEFAULT();

		setLabel(label, lang);

	}

	public void setLabel(String label, Language language){

		if (language != null){

			Representation repr = getRepresentation(language);

			if (repr != null){

				repr.setLabel(label);

			}else{

				repr = Representation.NewInstance(null, label, null, language);

			}

			this.addRepresentation(repr);

		}

	}

	public FeatureTree getDescriptiveSystem() {

		return descriptiveSystem;

	}

	public void setDescriptiveSystem(FeatureTree descriptiveSystem) {

		this.descriptiveSystem = descriptiveSystem;

	}

	/**

	 * Returns the {@link DescriptionBase descriptions} of

	 * <i>this</i> working set.

	 *

	 * @see    #addDescription(DescriptionBase)

	 * @see    #removeDescription(DescriptionBase)

	 */

	public Set<DescriptionBase> getDescriptions() {

		return descriptions;

	}

	/**

	 * Adds an existing {@link DescriptionBase description} to the set of

	 * {@link #getDescriptions() descriptions} of <i>this</i>

	 * working set.

	 *

	 * @param description	the description to be added to <i>this</i> working set

	 * @see    	   			#getDescriptions()

	 * @see    	   			WorkingSet#addDescription(DescriptionBase)

	 */

	public boolean addDescription(DescriptionBase description) {

		boolean result = this.descriptions.add(description);

		if (! description.getWorkingSets().contains(this)){

			description.addWorkingSet(this);

		}

		return result;

	}

	/**

	 * Removes one element from the set of {@link #getDescriptions() descriptions} involved

	 * in <i>this</i> working set.<BR>

	 *

	 * @param  description	the description which should be removed

	 * @see     		 	#getDescriptions()

	 * @see     		  	#addDescription(DescriptionBase)

	 * @see     		  	WorkingSet#removeDescription(DescriptionBase)

	 */

	public boolean removeDescription(DescriptionBase description) {

		boolean result = this.descriptions.remove(description);

		if (description.getWorkingSets().contains(this)){

			description.removeWorkingSet(this);

		}

		return result;

	}

	//*********************** CLONE ********************************************************/

	/**

	 * Clones <i>this</i> WorkingSet. This is a shortcut that enables to create

	 * a new instance that differs only slightly from <i>this</i> WorkingSet by

	 * modifying only some of the attributes.

	 * The descriptions and the descriptive system are the same, the representations

	 * are cloned.

	 *

	 * @see eu.etaxonomy.cdm.model.common.AnnotatableEntity#clone()

	 * @see java.lang.Object#clone()

	 */

	@Override

	public Object clone() {

		WorkingSet result;

		try {

			result = (WorkingSet)super.clone();

			//descriptions

			result.descriptions = new HashSet<>();

			for (DescriptionBase<?> desc: this.descriptions){

				result.addDescription(desc);

			}

			//representations

			result.representations = new HashSet<>();

			for (Representation rep : this.representations){

				result.addRepresentation((Representation)rep.clone());

			}

			//subtree filter

            result.taxonSubtreeFilter = new HashSet<>();

            for (TaxonNode subtree : this.taxonSubtreeFilter){

                result.addTaxonSubtree(subtree);

            }

            //geo filter

            result.geoFilter = new HashSet<>();

            for (NamedArea area : this.geoFilter){

                result.addGeoFilterArea(area);

            }

			return result;

		}catch (CloneNotSupportedException e) {

			logger.warn("Object does not implement cloneable");

			e.printStackTrace();

			return null;

		}

	}

}

/**

* 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.strategy.cache.description;

import java.util.UUID;

import eu.etaxonomy.cdm.model.common.Language;

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

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

import eu.etaxonomy.cdm.strategy.cache.common.IdentifiableEntityDefaultCacheStrategy;

/**

 * @author a.mueller

 * @since 07.05.2018

 *

 */

public class WorkingSetDefaultCacheStrategy

            extends IdentifiableEntityDefaultCacheStrategy<WorkingSet> {

    private static final long serialVersionUID = 3307740888390159983L;

    final static UUID uuid = UUID.fromString("4018e36d-6c6e-4f9e-950c-66e928b51a22");

    @Override

    public String getTitleCache(WorkingSet workingSet) {

        Representation preferredRepresentation = workingSet.getPreferredRepresentation(Language.DEFAULT());

        if (preferredRepresentation != null){

            if (isNotBlank(preferredRepresentation.getLabel())){

                return preferredRepresentation.getLabel();

            }

        }

        return super.getTitleCache(workingSet);

    }

    @Override

    protected UUID getUuid() {

        return uuid;

    }

}

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

		WorkingSet workingSet = WorkingSet.NewInstance();

		workingSet.addDescription(taxonDescription);

		workingSet.setLabel("My Workingset");

		workingSet.getDescriptiveSystem();

		handleAnnotatableEntity(workingSet);

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

			    WorkingSet.class,

        stepName = "Make WorkingSet IdentifiableEntity";

        tableName = "WorkingSet";

//        //#5149 remove unique index on Sequence_Reference.citations_id

//        tableName = "Sequence_Reference";

//        String columnName = "citations_id";

//        step = UniqueIndexDropper.NewInstance(tableName, columnName, !INCLUDE_AUDIT);

//        stepList.add(step);

//

//

//        //#6340 nom status invalid updater

//        step = NomStatusInvalidUpdater.NewInstance();

//        stepList.add(step);

//

//		//#6529

//		//Extend WorkingSet to allow a more fine grained definiton of taxon set

//		//min rank

//        stepName = "Add minRank column";

//        tableName = "WorkingSet";

//        newColumnName = "minRank_id";

//        String referencedTable = "DefinedTermBase";

//        step = ColumnAdder.NewIntegerInstance(stepName, tableName, newColumnName, INCLUDE_AUDIT, !NOT_NULL, referencedTable);

//        stepList.add(step);

//

//        //max rank

//        stepName = "Add maxRank column";

//        tableName = "WorkingSet";

//        newColumnName = "maxRank_id";

//        referencedTable = "DefinedTermBase";

//        step = ColumnAdder.NewIntegerInstance(stepName, tableName, newColumnName, INCLUDE_AUDIT, !NOT_NULL, referencedTable);

//        stepList.add(step);

//

//        //subtree filter

//        stepName= "Add geo filter MN table to WorkingSet";

//        String firstTableName = "WorkingSet";

//        String secondTableAlias = "NamedArea";

//        String secondTableName = "DefinedTermBase";

//        String attributeName = "geoFilter";

//        boolean isList = ! IS_LIST;

//        step = MnTableCreator.NewMnInstance(stepName, firstTableName, null, secondTableName, secondTableAlias, attributeName, INCLUDE_AUDIT, isList, IS_M_TO_M);

//        stepList.add(step);

//

//        //subtree filter

//        stepName= "Add subtree filter MN table to WorkingSet";

//        firstTableName = "WorkingSet";

//        secondTableName = "TaxonNode";

//        secondTableAlias = null;

//        attributeName = "taxonSubtreeFilter";

//        isList = ! IS_LIST;

//        step = MnTableCreator.NewMnInstance(stepName, firstTableName, null, secondTableName, secondTableAlias, attributeName, INCLUDE_AUDIT, isList, IS_M_TO_M);

//        stepList.add(step);

//

//        //#6258

//        stepName = "Add Registration table";

//        tableName = "Registration";

//        String[] columnNames = new String[]{"identifier","specificIdentifier","registrationDate","status",

//                "institution_id","name_id","submitter_id"};

//        String[] referencedTables = new String[]{null, null, null, null,

//                "AgentBase","TaxonNameBase","UserAccount"};

//        String[] columnTypes = new String[]{"string_255","string_255","datetime","string_10","int","int","int"};

//        step = TableCreator.NewAnnotatableInstance(stepName, tableName,

//                columnNames, columnTypes, referencedTables, INCLUDE_AUDIT);

//        stepList.add(step);

//

//        //add blockedBy_id

//        stepName= "Add blockedBy_id to Registration";

//        firstTableName = "Registration";

//        secondTableName = "Registration";

//        attributeName = "blockedBy";

//        isList = ! IS_LIST;

//        step = MnTableCreator.NewMnInstance(stepName, firstTableName, null, secondTableName, null, attributeName, INCLUDE_AUDIT, isList, IS_M_TO_M);

//        stepList.add(step);

//

//        //add type designations

//        stepName= "Add type designations to Registration";

//        firstTableName = "Registration";

//        String firstColumnName = "registrations";

//        secondTableName = "TypeDesignationBase";

//        attributeName = "typeDesignations";

//        isList = false;

//        step = MnTableCreator.NewMnInstance(stepName, firstTableName, null, firstColumnName, secondTableName, null, attributeName, INCLUDE_AUDIT, isList, IS_M_TO_M);

//        stepList.add(step);

//

//        //#5258

//        //Add "accessed" to Reference

//        stepName = "Add 'accessed' to Reference";

//        tableName = "Reference";

//        newColumnName = "accessed";

//        step = ColumnAdder.NewDateTimeInstance(stepName, tableName, newColumnName, INCLUDE_AUDIT, !NOT_NULL);

//        stepList.add(step);

//

//        //#6618 Add structure column to DefinedTermBase (Character)

//        stepName = "Add structure column to DefinedTermBase (Character)";

//        tableName = "DefinedTermBase";

//        newColumnName = "structure_id";

//        referencedTable = "FeatureNode";

//        step = ColumnAdder.NewIntegerInstance(stepName, tableName, newColumnName, INCLUDE_AUDIT, !NOT_NULL, referencedTable);

//        stepList.add(step);

//

//        //#6618 Add property column to DefinedTermBase (Character)

//        stepName = "Add property column to DefinedTermBase (Character)";

//        tableName = "DefinedTermBase";

//        newColumnName = "property_id";

//        referencedTable = "FeatureNode";

//        step = ColumnAdder.NewIntegerInstance(stepName, tableName, newColumnName, INCLUDE_AUDIT, !NOT_NULL, referencedTable);

//        stepList.add(step);

//

//        //##6661 Add initials to agent base

//        stepName = "Add initials to AgentBase";

//        tableName = "AgentBase";

//        newColumnName = "initials";

//        int length = 80;

//        step = ColumnAdder.NewStringInstance(stepName, tableName, newColumnName, length, INCLUDE_AUDIT);

//        stepList.add(step);

//

//        stepName = "Update initials and firstname";

//        step = InitialsUpdater.NewInstance();

//        stepList.add(step);

//

//        //#6663

//        //Add "lastRetrieved" to Reference

//        stepName = "Add 'lastRetrieved' to Reference";

//        tableName = "Reference";

//        newColumnName = "lastRetrieved";

//        step = ColumnAdder.NewDateTimeInstance(stepName, tableName, newColumnName, INCLUDE_AUDIT, !NOT_NULL);

//        stepList.add(step);

//

//        stepName = "Add externalId to Reference";

//        tableName = "Reference";

//        newColumnName = "externalId";

//        length = 255;

//        step = ColumnAdder.NewStringInstance(stepName, tableName, newColumnName, length, INCLUDE_AUDIT);

//        stepList.add(step);

//

//        stepName = "Add externalLink to Reference";

//        tableName = "Reference";