EDIT

import eu.etaxonomy.cdm.vaadin.util.formatter.DateTimeFormat;

import eu.etaxonomy.cdm.vaadin.util.formatter.TimePeriodFormatter;

    private TimePeriodFormatter timePeriodFormatter = new TimePeriodFormatter(DateTimeFormat.ISO8601_DATE);

import eu.etaxonomy.cdm.vaadin.util.formatter.DateTimeFormat;

import eu.etaxonomy.cdm.vaadin.util.formatter.TimePeriodFormatter;

    private TimePeriodFormatter timePeriodFormatter = new TimePeriodFormatter(DateTimeFormat.ISO8601_DATE);

/**

* Copyright (C) 2017 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.vaadin.util.converter;

import java.util.ArrayList;

import java.util.Collection;

import java.util.Collections;

import java.util.Comparator;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.List;

import java.util.Map;

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

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

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

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

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

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

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

/**

 * Converts a collection of TypeDesignations, which should belong to the

 * same name of course, into a string representation.

 *

 * Order of TypeDesignations in the resulting string:

 *  Type, Holotype, Lectotype, Epitypes

 * @author a.kohlbecker

 * @since Mar 10, 2017

 *

 */

public class TypeDesignationConverter {

    private final String separator = ", ";

    private Collection<TypeDesignationBase> typeDesignations;

    private Map<TypeDesignationStatusBase<?>, Collection<String>> orderedStrings;

    private String finalString = null;

    private String typifiedNameCache = null;

    /**

     * @param taxonNameBase

     *

     */

    public TypeDesignationConverter(Collection<TypeDesignationBase> typeDesignations, TaxonNameBase taxonNameBase) {

        this.typeDesignations = typeDesignations;

        orderedStrings = new HashMap<>(typeDesignations.size());

        if(taxonNameBase != null){

            this.typifiedNameCache = taxonNameBase.getTitleCache();

        }

    }

    private void putString(TypeDesignationStatusBase<?> status, String string){

        // the cdm orderd term bases are ordered invers, fixing this for here

        if(status == null){

            status = SpecimenTypeDesignationStatus.TYPE();

        }

        if(!orderedStrings.containsKey(status)){

            orderedStrings.put(status, new ArrayList<String>());

        }

        orderedStrings.get(status).add(string);

    }

    public TypeDesignationConverter buildString(){

        typeDesignations.forEach(td -> putString(td.getTypeStatus(), stringify(td)));

        StringBuilder sb = new StringBuilder();

        if(typifiedNameCache != null){

            sb.append(typifiedNameCache).append(": ");

        }

        List<TypeDesignationStatusBase<?>> keyList = new LinkedList<>(orderedStrings.keySet());

        Collections.sort(keyList, new Comparator<TypeDesignationStatusBase>() {

            @Override

            public int compare(TypeDesignationStatusBase o1, TypeDesignationStatusBase o2) {

                // fix inverted order of cdm terms by -1*

                return -1 * o1.compareTo(o2);

            }

        });

        keyList.forEach(key -> {

            if(key.equals( SpecimenTypeDesignationStatus.TYPE())){

                sb.append("Type");

            } else {

                sb.append(key.getPreferredRepresentation(Language.DEFAULT()));

            }

            sb.append(": ");

            orderedStrings.get(key).forEach(str -> {

                sb.append(str);

                if(sb.length() > 0){

                    sb.append(separator);

                }

            });

        });

        finalString  = sb.toString();

        return this;

    }

    /**

     * @param td

     * @return

     */

    private String stringify(TypeDesignationBase td) {

        if(td instanceof NameTypeDesignation){

            return stringify((NameTypeDesignation)td);

        } else {

            return stringify((SpecimenTypeDesignation)td);

        }

    }

    /**

     * @param td

     * @return

     */

    protected String stringify(NameTypeDesignation td) {

        StringBuffer sb = new StringBuffer();

        if(td.getTypeName() != null){

            sb.append(td.getTypeName().getTitleCache());

        }

        if(td.getCitation() != null){

            sb.append(" ").append(td.getCitation().getTitleCache());

            if(td.getCitationMicroReference() != null){

                sb.append(":").append(td.getCitationMicroReference());

            }

        }

        if(td.isNotDesignated()){

            sb.append(" not designated");

        }

        if(td.isRejectedType()){

            sb.append(" rejected");

        }

        if(td.isConservedType()){

            sb.append(" conserved");

        }

        return sb.toString();

    }

    /**

     * @param td

     * @return

     */

    private String stringify(SpecimenTypeDesignation td) {

        StringBuffer sb = new StringBuffer();

        if(td.getTypeSpecimen() != null){

            String nameTitleCache = td.getTypeSpecimen().getTitleCache();

            if(typifiedNameCache != null){

                nameTitleCache = nameTitleCache.replace(typifiedNameCache, "");

            }

            sb.append(nameTitleCache);

        }

        if(td.getCitation() != null){

            sb.append(" ").append(td.getCitation().getTitleCache());

            if(td.getCitationMicroReference() != null){

                sb.append(" :").append(td.getCitationMicroReference());

            }

        }

        if(td.isNotDesignated()){

            sb.append(" not designated");

        }

        return sb.toString();

    }

    public String print(){

        return finalString;

    }

}

/**

* Copyright (C) 2017 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.vaadin.util.formatter;

public enum DateTimeFormat {

    /**

     * yyyy-mm-dd or yyyy-mm or yyyy

     */

    ISO8601_DATE,

    /**

     * dd.mm.yyyy or mm.yyyy or yyyy

     */

    DMY_DOT,

}

/**

* Copyright (C) 2017 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.vaadin.util.formatter;

import org.joda.time.Partial;

import org.joda.time.format.DateTimeFormatter;

import org.joda.time.format.ISODateTimeFormat;

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

/**

 * @author a.kohlbecker

 * @since Apr 28, 2017

 *

 */

public class PartialFormatter {

    private DateTimeFormat format;

    private static final DateTimeFormatter dmyDotDayMonthYear =  org.joda.time.format.DateTimeFormat.forPattern("dd.MM.y");

    private static final DateTimeFormatter dmyDotMonthYear =  org.joda.time.format.DateTimeFormat.forPattern("MM.y");

    private static final DateTimeFormatter dmyDotYear =  org.joda.time.format.DateTimeFormat.forPattern("y");

    public PartialFormatter(DateTimeFormat format) {

        this.format = format;

    }

    public String print(Partial partial) {

        switch (format) {

            case DMY_DOT:

                return partial.toString(determine_DMY_DOT_Formatter(partial));

            case ISO8601_DATE:

            default:

                return partial.toString(determine_ISO860_Formatter(partial));

        }

    }

    /**

     * @param partial

     * @return

     */

    private DateTimeFormatter determine_ISO860_Formatter(Partial partial) {

        if (partial.isSupported(TimePeriod.DAY_TYPE)) {

            return ISODateTimeFormat.yearMonthDay();

        }

        if (partial.isSupported(TimePeriod.MONTH_TYPE)) {

            return ISODateTimeFormat.yearMonth();

        }

        return ISODateTimeFormat.year();

    }

    /**

     * @param partial

     * @return

     */

    private DateTimeFormatter determine_DMY_DOT_Formatter(Partial partial) {

        if (partial.isSupported(TimePeriod.DAY_TYPE)) {

            return dmyDotDayMonthYear;

        }

        if (partial.isSupported(TimePeriod.MONTH_TYPE)) {

            return dmyDotMonthYear;

        }

        return dmyDotYear;

    }

}

/**

* Copyright (C) 2017 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.vaadin.util.formatter;

import org.apache.commons.lang.StringUtils;

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

/**

 *

 * FIXME move into cdmlib

 *

 * @author a.kohlbecker

 * @since Apr 26, 2017

 *

 */

public class TimePeriodFormatter {

    private PartialFormatter partialFormatter;

    public TimePeriodFormatter(DateTimeFormat format) {

        partialFormatter = new PartialFormatter(format);

    }

    public String print(TimePeriod timePeriod) {

        if ( StringUtils.isNotBlank(timePeriod.getFreeText())){

           return timePeriod.getFreeText();

        }else{

            StringBuffer sb = new StringBuffer();

            if (timePeriod.getStart() != null) {

                sb.append(partialFormatter.print(timePeriod.getStart()));

            }

            if (timePeriod.getEnd() != null) {

                if (sb.length() > 0) {

                    sb.append(" - ");

                }

                sb.append(partialFormatter.print(timePeriod.getEnd()));

            }

            return sb.toString();

        }

    }

}

import eu.etaxonomy.cdm.vaadin.util.converter.TypeDesignationConverter;

/**

* Copyright (C) 2017 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.vaadin.util.formatter;

import org.joda.time.DateTimeFieldType;

import org.joda.time.Partial;

import org.junit.Assert;

import org.junit.Before;

import org.junit.Test;

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

/**

 * @author a.kohlbecker

 * @since Apr 28, 2017

 *

 */

public class PartialAndTimePeriodFormatterTest extends Assert {

    Partial dmy;

    Partial my;

    Partial y;

    @Before

    public void init(){

        dmy = new Partial(new DateTimeFieldType[]{

                DateTimeFieldType.year(),

                DateTimeFieldType.monthOfYear(),

                DateTimeFieldType.dayOfMonth()

        }, new int[] {1969, 04, 12});

        my = new Partial(new DateTimeFieldType[]{

                DateTimeFieldType.year(),

                DateTimeFieldType.monthOfYear()

        }, new int[] {1969, 04});

        y = new Partial(new DateTimeFieldType[]{

                DateTimeFieldType.year()

        }, new int[] {1969});

    }

    @Test

    public void test_Partial_ISO8601_DATE() {

        PartialFormatter f = new PartialFormatter(DateTimeFormat.ISO8601_DATE);

        assertEquals("1969-04-12", f.print(dmy));

        assertEquals("1969-04", f.print(my));

        assertEquals("1969", f.print(y));

    }

    @Test

    public void test_Partial_DMY_DOT() {

        PartialFormatter f = new PartialFormatter(DateTimeFormat.DMY_DOT);

        assertEquals("12.04.1969", f.print(dmy));

        assertEquals("04.1969", f.print(my));

        assertEquals("1969", f.print(y));

    }

    @Test

    public void test_TimePeriod_ISO8601_DATE() {

        TimePeriodFormatter f = new TimePeriodFormatter(DateTimeFormat.ISO8601_DATE);

        TimePeriod p1 = TimePeriod.NewInstance();

        p1.setStart(my);

        assertEquals("1969-04", f.print(p1));

        TimePeriod p2 = TimePeriod.NewInstance();

        p2.setEnd(dmy);

        assertEquals("1969-04-12", f.print(p2));

        TimePeriod p3 = TimePeriod.NewInstance(my, dmy);

        assertEquals("1969-04 - 1969-04-12", f.print(p3));

        TimePeriod p4 = TimePeriod.NewInstance(my, dmy);

        p4.setFreeText("in April 1969");

        assertEquals("in April 1969", f.print(p4));

    }

    @Test

    public void test_TimePeriod_DMY_DOT() {

        TimePeriodFormatter f = new TimePeriodFormatter(DateTimeFormat.DMY_DOT);

        TimePeriod p1 = TimePeriod.NewInstance();

        p1.setStart(my);

        assertEquals("04.1969", f.print(p1));

        TimePeriod p2 = TimePeriod.NewInstance();

        p2.setEnd(dmy);

        assertEquals("12.04.1969", f.print(p2));

        TimePeriod p3 = TimePeriod.NewInstance(my, dmy);

        assertEquals("04.1969 - 12.04.1969", f.print(p3));

        TimePeriod p4 = TimePeriod.NewInstance(my, dmy);

        p4.setFreeText("in April 1969");

        assertEquals("in April 1969", f.print(p4));

    }

}