EDIT

            if (!state.getConfig().isIncludeUnpublishedTaxa() && !taxon.isPublish()){

           if (!syn.isPublish() && !state.getConfig().isIncludeUnpublishedTaxa()){

	protected boolean includeUnpublishedTaxa;

    public boolean isIncludeUnpublishedTaxa() {

        return includeUnpublishedTaxa;

    public void setIncludeUnpublishedTaxa(boolean includeUnpublished) {

        this.includeUnpublishedTaxa = includeUnpublished;

    private boolean includeUnpublished = false;

        return new TaxonNodeFilter().setRankMin(rankMin).setRankMax(rankMax);

            Collection<UUID> taxonUuids, Collection<UUID> areaUuids,

            UUID minRank, UUID maxRank){

        TaxonNodeFilter result = new TaxonNodeFilter().setRankMin(minRank).setRankMax(maxRank);

        areaUuids = areaUuids == null ? new ArrayList<>(): areaUuids;

        for (UUID uuid : areaUuids){

            result.orArea(uuid);

        }

    /**

     * Constructor for a given subtree represented by a {@link TaxonNode}

     */

            this.rankMin = new LogicFilter<>(rankMin);

            this.rankMax = new LogicFilter<>(rankMax);

    /**

     * Adds a single {@link TaxonNode} to the filter.<BR><BR>

     * NOTE: this adds only the node to the filter, not it's children!

     */

    /**

     * Adds a single {@link TaxonNode} to the filter.<BR><BR>

     * NOTE: this adds only the node to the filter, not it's children!

     */

    public TaxonNodeFilter orArea(NamedArea area){

        areaFilter.add( new LogicFilter<>(area, Op.OR));

        return this;

    }

    public TaxonNodeFilter andArea(NamedArea area){

        areaFilter.add( new LogicFilter<>(area, Op.AND));

        return this;

    }

    public TaxonNodeFilter setRankMin(Rank rankMin){

        this.rankMin = rankMin == null? null : new LogicFilter<>(rankMin, Op.AND);

        return this;

    }

    public TaxonNodeFilter setRankMin(UUID rankMinUuid){

        this.rankMin = rankMinUuid == null? null : new LogicFilter<>(Rank.class, rankMinUuid, Op.AND);

    public TaxonNodeFilter setRankMax(Rank rankMax){

        this.rankMax = rankMax == null? null : new LogicFilter<>(rankMax, Op.AND);

        return this;

    }

    public TaxonNodeFilter setRankMax(UUID rankMaxUuid){

        this.rankMax = rankMaxUuid == null? null : new LogicFilter<>(Rank.class, rankMaxUuid, Op.AND);

    public LogicFilter<Rank> getRankMax() {

        return rankMax;

    }

    public LogicFilter<Rank> getRankMin() {

        return rankMin;

    }

    public boolean isIncludeUnpublished() {

        return includeUnpublished;

    }

    public void setIncludeUnpublished(boolean includeUnpublished) {

        this.includeUnpublished = includeUnpublished;

    }

    /**

     * If <code>true</code> the result will include the root node of

     * a classification.

     * Note: As a root node per se has no taxon all filters with filter

     * on taxon related data have no effect for the root node. If the

     * root node is returned only depends on the

     * {@link TaxonNodeFilter#isIncludeRootNodes() includeRootNodes}

     * parameter.

     */

    private static final String HQL_TRUE = " 1 "; //maybe we can/should use 'true' instead, needs to be checked for all DB types

        String unpublishFilter = getUnpublishFilter(filter);

                rankMaxFilter, rankMinFilter, areaFilter, rootNodeFilter,

                unpublishFilter);

        if (hasTaxonFilter(filter)){

            from += " LEFT JOIN tn.taxon taxon ";  //LEFT to allow includeRootNode

        }

            from += " INNER JOIN taxon.descriptions descriptions "

                  + " INNER JOIN descriptions.descriptionElements " + DESCRIPTION_ELEMENTS + " ";

    /**

     * @return

     */

    private boolean hasTaxonFilter(TaxonNodeFilter filter) {

        boolean result = !filter.getAreaFilter().isEmpty()

                || !filter.isIncludeUnpublished();

        return result;

    }

    private String getUnpublishFilter(TaxonNodeFilter filter) {

        String result = "";

        if (!filter.isIncludeUnpublished()){

            result = " ( taxon.publish = "+HQL_TRUE+" OR tn.parent IS NULL ) ";

        }

        return result;

    }

            String taxonFilter, String rankMaxFilter, String rankMinFilter, String areaFilter, String rootNodeFilter,

            String unpublishFilter) {

                classificationFilter, taxonFilter, rankMaxFilter, rankMinFilter, areaFilter, rootNodeFilter,

                unpublishFilter) + ") ";

    private TaxonNode nodeUnpublished;

    private Taxon taxonUnpublished;

         *   - node3 (taxon3, Species, Germany)  //if subspecies exists in Denmark this is not fully correct !!

        taxonUnpublished = Taxon.NewInstance(TaxonName.NewInstance(NomenclaturalCode.ICNAFP, Rank.SUBSPECIES(), null, null, null, null, null, null, null, null), null);

        taxonUnpublished.setPublish(false);

        nodeUnpublished = node3.addChildTaxon(taxonUnpublished, citation, microCitation);

        nodeUnpublished = taxonNodeDao.save(nodeUnpublished);

        TaxonNodeFilter filter = new TaxonNodeFilter();

        assertEquals(message, 5, listUuid.size());  //test start condition without rank filter

        filter = new TaxonNodeFilter(Rank.SPECIES(), Rank.GENUS());

        listUuid = filterDao.listUuids(filter);

        //reset

        Rank nullRank = null;

        filter.setRankMax(nullRank).setRankMin(nullRank);

        listUuid = filterDao.listUuids(filter);

        assertEquals("Reseting the rank filters should work", 5, listUuid.size());

        filter = new TaxonNodeFilter(Rank.KINGDOM(), Rank.ORDER());

        UUID nullUuid = null;

        filter.setRankMax(nullUuid).setRankMin(nullUuid);

        listUuid = filterDao.listUuids(filter);

        assertEquals("Reseting the rank filters should work", 5, listUuid.size());

    @Test

    public void testIncludeUnpublished(){

        Classification classification = classificationDao.findByUuid(classification1.getUuid());

        TaxonNodeFilter filter = new TaxonNodeFilter(classification.getRootNode());

        List<UUID> listUuid = filterDao.listUuids(filter);

        Assert.assertEquals("All 5 children but not root node should be returned", 5, listUuid.size());

        filter.setIncludeUnpublished(true);

        listUuid = filterDao.listUuids(filter);

        Assert.assertEquals("All 6 children including unpublished should be returned", 6, listUuid.size());

        filter.setIncludeRootNodes(true);

        listUuid = filterDao.listUuids(filter);

        Assert.assertEquals("All 7 children including root node should be returned", 7, listUuid.size());

    }

        //New

        filter = new TaxonNodeFilter(node1);  //4 children, see above

        filter.orClassification(classification.getUuid());//4 children, see above

        filter.setRankMax(Rank.uuidSpecies);

        listUuid = filterDao.listUuids(filter);

        Assert.assertEquals("3 children should be returned", 3, listUuid.size());

        filter.setRankMin(Rank.uuidSpecies);

        listUuid = filterDao.listUuids(filter);

        Assert.assertEquals("Only species should be returned", 1, listUuid.size());

        Rank nullRank = null;

        filter.setRankMin(nullRank);

        filter.setIncludeUnpublished(true);

        listUuid = filterDao.listUuids(filter);

        Assert.assertEquals("4 children should be returned, including unpublished", 4, listUuid.size());

        NamedArea germany = HibernateProxyHelper.deproxy(termDao.load(germanyUuid), NamedArea.class);

        filter.orArea(germany);

        listUuid = filterDao.listUuids(filter);

        Assert.assertEquals("1 child should be returned", 1, listUuid.size());

//            @RequestParam(value = "includeUnpublished", defaultValue="false") Boolean includeUnpublished,  //for now we do not allow unpublished data to be exported via webservice as long as read authentication is not implemented

            @RequestParam(value = "area", required = false) final UuidList areaUuids,

            @RequestParam(value = "minRank", required = false) final UUID minRank,

            @RequestParam(value = "minRank", required = false) final UUID maxRank,

                                    classificationUuids, subtreeUuids, taxonNodeUuids, taxonUuids,

                                    areaUuids, minRank, maxRank);

                                    withHigherClassification, includeHeader, includeUnpublished );

            Boolean includeUnpublished) {

        config.setIncludeUnpublishedTaxa(includeUnpublished);