EDIT

// $Id$

/**

* Copyright (C) 2016 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.persistence.dto;

public enum TaxonStatus{

    Accepted,

    SynonymObjective,

    Synonym; //All others including undefined and explicitly subjective /heterotypic synonyms

    public boolean isSynonym(){

       return this == SynonymObjective || this == Synonym;

    }

}

import java.util.Set;

import javax.persistence.EntityNotFoundException;

import org.apache.commons.lang.StringUtils;

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

    public TaxonInContextDTO getTaxonInContext(UUID classificationUuid, UUID taxonBaseUuid,

        TaxonBase<?> taxonBase = taxonDao.load(taxonBaseUuid);

            throw new EntityNotFoundException("Taxon with uuid " + taxonBaseUuid + " not found in datasource");

        }

        boolean isSynonym = false;

        Taxon acceptedTaxon;

        if (taxonBase.isInstanceOf(Synonym.class)){

            isSynonym = true;

            Synonym synonym = CdmBase.deproxy(taxonBase, Synonym.class);

            Set<Taxon> acceptedTaxa = synonym.getAcceptedTaxa();

            //we expect every synonym to have only 1 accepted taxon as this is how

            //CDM will be modelled soon

            acceptedTaxon = acceptedTaxa.isEmpty()? null : acceptedTaxa.iterator().next();

            if (acceptedTaxon == null) {

                throw new EntityNotFoundException("Accepted taxon not found for synonym"  );

            }

            TaxonStatus taxonStatus = TaxonStatus.Synonym;

            if (synonym.getName()!= null && acceptedTaxon.getName() != null

                    && synonym.getName().getHomotypicalGroup().equals(acceptedTaxon.getName().getHomotypicalGroup())){

                taxonStatus = TaxonStatus.SynonymObjective;

            }

            result.setTaxonStatus(taxonStatus);

        }else{

            acceptedTaxon = CdmBase.deproxy(taxonBase, Taxon.class);

            result.setTaxonStatus(TaxonStatus.Accepted);

        }

        UUID acceptedTaxonUuid = acceptedTaxon.getUuid();

        UUID taxonNodeUuid = getTaxonNodeUuidByTaxonUuid(classificationUuid, acceptedTaxonUuid);

        if (taxonNodeUuid == null) {

            throw new EntityNotFoundException("Taxon not found in classficiation with uuid " + classificationUuid + ". Either classification does not exist or does not contain taxon/synonym with uuid " + taxonBaseUuid );

        }

        result.setTaxonNodeUuid(taxonNodeUuid);

        result.setTaxonUuid(taxonBaseUuid);

        result.setClassificationUuid(classificationUuid);

        if (taxonBase.getSec() != null){

            result.setSecundumUuid(taxonBase.getSec().getUuid());

            result.setSecundumLabel(taxonBase.getSec().getTitleCache());

        result.setTaxonLabel(taxonBase.getTitleCache());

                String rankLabel = rank.getAbbreviation();

                if (StringUtils.isBlank(rankLabel)){

                    rankLabel = rank.getLabel();

                }

                result.setRankLabel(rankLabel);

        if(! isSynonym) {

            for (TaxonNodeDto childDto : children.getRecords()){

                if (doChildren && childDto.getStatus().equals(TaxonStatus.Accepted)){

                    EntityDTO<Taxon> child = new EntityDTO<Taxon>(childDto.getTaxonUuid(), childDto.getTitleCache());

                    result.addChild(child);

                }else if (doSynonyms && childDto.getStatus().isSynonym()){

                    EntityDTO<Synonym> child = new EntityDTO<Synonym>(childDto.getTaxonUuid(), childDto.getTitleCache());

                    result.addSynonym(child);

                }

        }else{

            result.setAcceptedTaxonUuid(acceptedTaxonUuid);

            String nameTitel = acceptedTaxon.getName() == null ? null : acceptedTaxon.getName().getTitleCache();

            result.setAcceptedTaxonLabel(acceptedTaxon.getTitleCache());

            result.setAcceptedNameLabel(nameTitel);

                String label =  taxon.getName() == null? taxon.getTitleCache() : taxon.getName().getTitleCache();

                MarkedEntityDTO<Taxon> dto = new MarkedEntityDTO<>(type, true, taxon.getUuid(), label);

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

    private TaxonStatus taxonStatus;

    //accepted taxon

    private UUID acceptedTaxonUuid;

    private String acceptedNameLabel;

    private String acceptedTaxonLabel;

    /**

     * @return the acceptedTaxonLabel

     */

    public String getAcceptedTaxonLabel() {

        return acceptedTaxonLabel;

    }

    /**

     * @param acceptedTaxonLabel the acceptedTaxonLabel to set

     */

    public void setAcceptedTaxonLabel(String acceptedTaxonLabel) {

        this.acceptedTaxonLabel = acceptedTaxonLabel;

    }

    /**

     * @return the acceptedTaxonUuid

     */

    public UUID getAcceptedTaxonUuid() {

        return acceptedTaxonUuid;

    }

    /**

     * @param acceptedTaxonUuid the acceptedTaxonUuid to set

     */

    public void setAcceptedTaxonUuid(UUID acceptedTaxonUuid) {

        this.acceptedTaxonUuid = acceptedTaxonUuid;

    }

    /**

     * @return the acceptedNameLabel

     */

    public String getAcceptedNameLabel() {

        return acceptedNameLabel;

    }

    /**

     * @param acceptedNameLabel the acceptedNameLabel to set

     */

    public void setAcceptedNameLabel(String acceptedNameLabel) {

        this.acceptedNameLabel = acceptedNameLabel;

    }

    /**

     * @return the taxonStatus

     */

    public TaxonStatus getTaxonStatus() {

        return taxonStatus;

    }

    /**

     * @param taxonStatus the taxonStatus to set

     */

    public void setTaxonStatus(TaxonStatus taxonStatus) {

        this.taxonStatus = taxonStatus;

    }