EDIT

/**

* 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.persistence.dto;

import java.util.Comparator;

import java.util.StringTokenizer;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.common.AbstractStringComparator;

import eu.etaxonomy.cdm.common.UTF8;

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

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

/**

 * @author k.luther/a.kohlbecker

 * @since 09.03.2018

 *

 */

public class TaxonNodeDtoByNameComparator extends AbstractStringComparator<TaxonNodeDto> implements Comparator<TaxonNodeDto>, ITaxonNodeComparator<TaxonNodeDto>{

    private static final String HYBRID_SIGN = UTF8.HYBRID.toString();

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

    private boolean ignoreHybridSign = true;

    private boolean sortInfraGenericFirst = true;

    @Override

    public int compare(TaxonNodeDto node1, TaxonNodeDto node2) {

        if (node1 == null && node2 == null) {

            return 0;

        }

        else if (node1 == null) {

            return 1;

        }

        else if (node2 == null) {

            return -1;

        }

        if (node1.equals(node2)){

            return 0;

        }

        boolean node1Excluded = node1.isExcluded();

        boolean node2Excluded = node2.isExcluded();

        boolean node1Unplaced = node1.isUnplaced();

        boolean node2Unplaced = node2.isUnplaced();

      //They should both be put to the end (first unplaced then excluded)

        if (node2Excluded && !node1Excluded){

            return -1;

        }

        if (node2Unplaced && !(node1Unplaced || node1Excluded)){

            return -1;

        }

        if (node1Excluded && !node2Excluded){

            return 1;

        }

        if (node1Unplaced && !(node2Unplaced || node2Excluded)){

            return 1;

        }

        if (node1Unplaced && node2Excluded){

            return -1;

        }

        if (node2Unplaced && node1Excluded){

            return 1;

        }

        String titleCache1 = createSortableTitleCache(node1);

        String titleCache2 = createSortableTitleCache(node2);

        if(isIgnoreHybridSign()) {

            if (logger.isTraceEnabled()){logger.trace("ignoring Hybrid Signs: " + HYBRID_SIGN);}

            titleCache1 = titleCache1.replace(HYBRID_SIGN, "");

            titleCache2 = titleCache2.replace(HYBRID_SIGN, "");

        }

        titleCache1 = applySubstitutionRules(titleCache1);

        titleCache2 = applySubstitutionRules(titleCache2);

        // 1

        StringTokenizer s2 = new StringTokenizer(titleCache1, "\"");

        if (s2.countTokens()>0){

            titleCache1 = "";

        }

        while(s2.hasMoreTokens()){

            titleCache1 += s2.nextToken();

        }

        // 2

        s2 = new StringTokenizer(titleCache2, "\"");

        if (s2.countTokens()>0){

            titleCache2 = "";

        }

        while(s2.hasMoreTokens()){

            titleCache2 += s2.nextToken();

        }

        int result = titleCache1.compareTo(titleCache2);

        if (result != 0){

            return result;

        }else{

            return node1.getUuid().compareTo(node2.getUuid());

        }

    }

    private String createSortableTitleCache(TaxonNodeDto taxonNode) {

        String nameTitleCache= taxonNode.getTitleCache();

        if (nameTitleCache == null){

            if (logger.isTraceEnabled()){logger.trace("titleCache still null, using taxonNode id");}

            nameTitleCache = String.valueOf(taxonNode.getId());

        }

        if (logger.isTraceEnabled()){logger.trace("SortableTitleCache: " + nameTitleCache);}

//            System.out.println(titleCache);

        return nameTitleCache;

    }

    @Override

    public boolean isIgnoreHybridSign() {

        return ignoreHybridSign;

    }

    @Override

    public void setIgnoreHybridSign(boolean ignore) {

        this.ignoreHybridSign = ignore;

    }

    public boolean isSortInfraGenericFirst() {

        return sortInfraGenericFirst;

    }

    public void setSortInfraGenericFirst(boolean infraGenericFirst) {

        this.sortInfraGenericFirst = infraGenericFirst;

    }

}

/**

* 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.persistence.dto;

import java.io.Serializable;

import java.util.Comparator;

import java.util.UUID;

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

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

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

/**

 * @author k.luther

 * @since 18.03.2010

 *

 */

public class TaxonNodeDtoByRankAndNameComparator implements Serializable, Comparator<TaxonNodeDto> {

	private static final long serialVersionUID = 2596641007876609704L;

	@Override

    public int compare(TaxonNodeDto node1, TaxonNodeDto node2) {

	    boolean node1Excluded = node1.isExcluded();

	    boolean node2Excluded = node2.isExcluded();

	    boolean node1Unplaced = node1.isUnplaced();

	    boolean node2Unplaced = node2.isUnplaced();

		if (node1.getUuid().equals(node2.getUuid())){

			return 0;

		}

		//They should both be put to the end (first unplaced then excluded)

		if (node2Excluded && !node1Excluded){

		    return -1;

		}

		if (node2Unplaced && !(node1Unplaced || node1Excluded)){

		    return -1;

		}

		if (node1Excluded && !node2Excluded){

            return 1;

        }

        if (node1Unplaced && !(node2Unplaced || node2Excluded)){

            return 1;

        }

        if (node1Unplaced && node2Excluded){

            return -1;

        }

        if (node2Unplaced && node1Excluded){

            return 1;

        }

		Integer rankTax1 = node1.getRankOrderIndex();

		Integer rankTax2 = node2.getRankOrderIndex();

		//first compare ranks, if ranks are equal (or both null) compare names or taxon title cache if names are null

		int rankOrder = OrderIndexComparator.instance().compare(rankTax1, rankTax2);

		if (rankOrder == 0) {

			if (node1.getTitleCache() != null && node2.getTitleCache() != null){

				//same rank, order by name

				int result = node1.getNameTitleCache().compareTo(node2.getNameTitleCache());

				if (result == 0){

					return node1.getTaxonUuid().compareTo(node2.getTaxonUuid());

				}else{

					return result;

				}

			}else {

				//this is maybe not 100% correct, we need to compare name cases, but it is a very rare case

				return node1.getTaxonTitleCache().compareTo(node2.getTaxonTitleCache());

			}

		}else{

			//rankTax2.isHigher(rankTax1)

			return rankOrder;

		}

	}

    /**

     * @param taxon1

     * @return

     */

    public String getTaxonTitle(TaxonBase<?> taxon, TaxonNode node) {

        return (taxon == null) ? node.getUuid().toString(): taxon.getTitleCache();

    }

    /**

     * @param taxon

     * @param node

     * @return

     */

    private UUID getTaxonUuid(TaxonBase<?> taxon, TaxonNode node) {

        return (taxon == null) ? node.getUuid(): taxon.getUuid();

    }

}

/**

* 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.persistence.dto;

import java.util.Comparator;

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

/**

 * Comparator to compare {@link TaxonNode taxon nodes} by its user defined ordering

 *

 * @author k.luther

 */

public class TaxonNodeDtoNaturalComparator implements Comparator<TaxonNodeDto> {

    public TaxonNodeDtoNaturalComparator(){

		super();

	}

	@SuppressWarnings("null")

    @Override

	public int compare(TaxonNodeDto node1, TaxonNodeDto node2) {

	   // System.out.println("compare node 1: "+ node1.getTaxon().getTitleCache() + " - node 2: " + node2.getTaxon().getTitleCache());

	    if (node1.equals(node2)) {

	        return 0;

        }

	    // if we do not check for null for the treeIndex we always return 1 if one of the nodes have no treeIndex

	    if (node1.getTreeIndex() == null){

	        return 1;

	    }

	    if (node2.getTreeIndex() == null){

            return -1;

        }

	    if (node1.getParentUUID().equals(node2.getParentUUID())){

            return node1.getSortIndex().compareTo(node2.getSortIndex());

        }

	    if (node2.getTreeIndex().startsWith(node1.getTreeIndex())) {

            return -1;

        }

		if (node1.getTreeIndex().startsWith(node2.getTreeIndex())) {

            return 1;

        }

//		String[] splitNode1 = node1.getTreeIndex().split("#");

//		String[] splitNode2 = node2.getTreeIndex().split("#");

//		String lastEqualAncestorTreeIndex = "";

//		List<TaxonNodeDto> ancestorAndNode= new ArrayList<>();

//		ancestorAndNode.add(node1);

//		ancestorAndNode.addAll(node1.getAncestors());

//		java.util.Collections.sort(ancestorAndNode, new TreeIndexComparator());

//

//

//		List<TaxonNode> ancestorAndNode2= new ArrayList<>();

//        ancestorAndNode2.add(node2);

//        ancestorAndNode2.addAll(node2.getAncestors());

//        java.util.Collections.sort(ancestorAndNode2, new TreeIndexComparator());

//

//		for (int i = 0; i < splitNode1.length; i++){

//			if (!splitNode1[i].equals(splitNode2[i])){

//				// take the last equal ancestor and compare the sortindex

//				if (lastEqualAncestorTreeIndex != null){

//					TaxonNode lastEqualTreeIndexAncestorNode1 = null;

//					TaxonNode lastEqualTreeIndexAncestorNode2 = null;

//					for (TaxonNode next1 :ancestorAndNode){

//

//						if (next1.treeIndex().equals(lastEqualAncestorTreeIndex+"#"+splitNode1[i]+ "#") ){

//						    lastEqualTreeIndexAncestorNode1 = next1;

//						}

//					}

//					for (TaxonNode next2 :ancestorAndNode2){

//

//						if (next2.treeIndex().equals(lastEqualAncestorTreeIndex+"#"+splitNode2[i]+ "#")){

//						    lastEqualTreeIndexAncestorNode2 = next2;

//						}

//					}

//					return lastEqualTreeIndexAncestorNode1.getSortIndex().compareTo(lastEqualTreeIndexAncestorNode2.getSortIndex());

//				}

//			}

//			if (!splitNode1[i].equals("")){

//			    lastEqualAncestorTreeIndex = lastEqualAncestorTreeIndex+"#"+splitNode1[i];

//			}

//		}

		return 0;

	}

	private final class TreeIndexComparator implements Comparator<TaxonNodeDto> {

	    @Override

	    public int compare(TaxonNodeDto node1,TaxonNodeDto node2){

	        return node1.getTreeIndex().compareTo(node2.getTreeIndex());

	    }

	}

}

/**

* 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.HashSet;

import java.util.Set;

import java.util.UUID;

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

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

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

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

/**

 * @author k.luther

 * @since 30.11.2018

 *

 */

public class TaxonDescriptionDTO implements Serializable{

    private static final long serialVersionUID = -4440059497898077690L;

    UUID taxonUuid;

    Set<TaxonDescription> descriptions = new HashSet();

    public TaxonDescriptionDTO(Taxon taxon){

        this.taxonUuid = taxon.getUuid();

        for (TaxonDescription desc: taxon.getDescriptions()){

            for (DescriptionElementBase element: desc.getElements()){

                if (element instanceof Distribution){

                    descriptions.add(desc);

                    break;

                }

            }

        }

    }

    /**

     * @return the taxonUuid

     */

    public UUID getTaxonUuid() {

        return taxonUuid;

    }

    /**

     * @param taxonUuid the taxonUuid to set

     */

    public void setTaxonUuid(UUID taxonUuid) {

        this.taxonUuid = taxonUuid;

    }

    /**

     * @return the descriptions

     */

    public Set<TaxonDescription> getDescriptions() {

        return descriptions;

    }

    /**

     * @param descriptions the descriptions to set

     */

    public void setDescriptions(Set<TaxonDescription> descriptions) {

        this.descriptions = descriptions;

    }

}

/**

* 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.HashMap;

import java.util.HashSet;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

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

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

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

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

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

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

/**

 * @author k.luther

 * @since 27.11.2018

 *

 */

public class TaxonDistributionDTO implements Serializable{

    private static final long serialVersionUID = -6565463192135410612L;

    UUID taxonUuid;

    String nameCache;

    Rank rank;

    TaxonDescriptionDTO descriptionsWrapper;

    Map<NamedArea,Set<DescriptionElementBase>> distributionMap = new HashMap();

    public TaxonDistributionDTO(Taxon taxon){

        this.taxonUuid = taxon.getUuid();

        this.nameCache = taxon.getName().getNameCache();

        this.descriptionsWrapper = new TaxonDescriptionDTO(taxon);

        for (TaxonDescription desc: descriptionsWrapper.descriptions){

            for (DescriptionElementBase descElement: desc.getElements()){

                if (descElement instanceof Distribution){

                    Set<DescriptionElementBase> distributions = distributionMap.get(((Distribution)descElement).getArea());

                    if (distributions == null){

                        distributions = new HashSet();

                        distributionMap.put(((Distribution)descElement).getArea(), distributions);

                    }

                    distributions.add(descElement);

                }

            }

        }

    }

   /* ------ Getter / Setter -----------*/

    /**

     * @return the taxonUuid

     */

    public UUID getTaxonUuid() {

        return taxonUuid;

    }

    /**

     * @param taxonUuid the taxonUuid to set

     */

    public void setTaxonUuid(UUID taxonUuid) {

        this.taxonUuid = taxonUuid;

    }

    /**

     * @return the nameCache

     */

    public String getNameCache() {

        return nameCache;

    }

    /**

     * @param nameCache the nameCache to set

     */

    public void setNameCache(String nameCache) {

        this.nameCache = nameCache;

    }

    /**

     * @return the rankString

     */

    public String getRankString() {

        return rank.getLabel();

    }

    /**

     * @return the rank

     */

    public Rank getRank() {

        return rank;

    }

    /**

     * @param rank the rank to set

     */

    public void setRank(Rank rank) {

        this.rank = rank;

    }

    /**

     * @return the descriptionsWrapper

     */

    public TaxonDescriptionDTO getDescriptionsWrapper() {

        return descriptionsWrapper;

    }

    /**

     * @param descriptionsWrapper the descriptionsWrapper to set

     */

    public void setDescriptionsWrapper(TaxonDescriptionDTO descriptionsWrapper) {

        this.descriptionsWrapper = descriptionsWrapper;

    }

    /**

     * @return the distributionMap

     */

    public Map<NamedArea, Set<DescriptionElementBase>> getDistributionMap() {

        return distributionMap;

    }

    /**

     * @param distributionMap the distributionMap to set

     */

    public void setDistributionMap(Map<NamedArea, Set<DescriptionElementBase>> distributionMap) {

        this.distributionMap = distributionMap;

    }

}