io.lsn.spring.common.helper.DateHelper Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of common Show documentation
Logisfera Nova Commons holds a bunch of useful helpers such as validators, conditional register process, soap logging handler
The newest version!
package io.lsn.spring.common.helper;

import org.joda.time.DateTime;
import org.joda.time.Months;
import org.joda.time.Years;

import javax.xml.datatype.DatatypeConfigurationException;
import javax.xml.datatype.DatatypeConstants;
import javax.xml.datatype.DatatypeFactory;
import javax.xml.datatype.XMLGregorianCalendar;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.ZoneId;
import java.time.temporal.ChronoUnit;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;

/**
 * @author Patryk Szlagowski 
 */
public class DateHelper {

    /**
     * Converts Tibco's string-as-date to Java Date format
     *
     * @param tibcoStringDate
     * @return
     */
    public static Date tibcoStringToDate(String tibcoStringDate) {
        return stringToDate(tibcoStringDate, "yyyy-MM-dd");
    }

    /**
     * map string date to Date object with given pattern
     * @param date
     * @param pattern
     * @return
     */
    public static Date stringToDate(String date, String pattern) {
        if ("0000-00-00".equals(date)) {
            return null;
        }

        try {
            DateFormat f = new SimpleDateFormat(pattern);
            Date result = f.parse(date);
            return result;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * converts date to localdate
     *
     * @param input
     * @return
     */
    public static LocalDate toLocalDate(Date input) {
        if (input == null) {
            return null;
        }

        LocalDate date = input.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        return date;
    }

    /**
     * return truncated date with alice formatting
     *
     * @param date
     * @return
     */
    public static String aliceShortDate(Date date) {
        if (date != null) {
            Date resultDate = truncate(date);
            DateFormat f = new SimpleDateFormat("yyyy-MM-dd");
            return f.format(resultDate);
        } else {
            return null;
        }
    }

    /**
     * return timestamp value of provided date
     *
     * @param date date for timestamp
     * @return timestamp version of date
     */
    public static String timestamp(Date date) {
        if (date != null) {
            DateFormat f = new SimpleDateFormat("yyyy-MM-dd H:mm:s:S");
            return f.format(date);
        } else {
            return null;
        }
    }

    /**
     * current timestamp
     *
     * @return current timestamp
     */
    public static String timestamp() {
        return timestamp(new Date());
    }


    /**
     * Calculate months between dates
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static long ageInMonth(Date startDate, Date endDate) {
        return Months.monthsBetween(new DateTime(startDate), new DateTime(endDate)).getMonths();
    }

    /**
     * Calculate full years between dates
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static long ageInYears(Date startDate, Date endDate) {
        long ageInMonths = ageInMonth(startDate, endDate);
        return Math.floorDiv(ageInMonths, 12);
    }


    /**
     * Calculate full years since date
     *
     * @param startDate
     * @return
     */
    public static long ageInYears(Date startDate) {
        long ageInMonths = ageInMonth(startDate);
        return Math.floorDiv(ageInMonths, 12);
    }

    /**
     * Calculate months between provided date and current timestamp
     *
     * @param startDate
     * @return
     */
    public static long ageInMonth(Date startDate) {
        return ageInMonth(startDate, new Date());
    }


    /**
     * Calculate days  between dates
     *
     * @param startDate
     * @param endDate
     * @return
     */
    public static long ageInDays(Date startDate, Date endDate) {
        LocalDate sd = startDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        LocalDate ed = endDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
        return ChronoUnit.DAYS.between(sd, ed);
    }

    /**
     * Calculate days between dates
     *
     * @param verificationDate
     * @return
     */
    public static long ageInDays(Date verificationDate) {
        return ageInDays(verificationDate, new Date());
    }


    public static Date truncate(Date dateToTrim) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(dateToTrim);
        cal.set(Calendar.HOUR_OF_DAY, 0);
        cal.set(Calendar.MINUTE, 0);
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        return cal.getTime();
    }

    /**
     * returns truncated date with added days
     *
     * @param startDate
     * @param days
     * @return
     */
    public static Date trunacateAndAddDays(Date startDate, int days) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(startDate);
        cal.add(Calendar.DAY_OF_YEAR, days);
        return truncate(cal.getTime());
    }

    /**
     * add days to current date
     *
     * @param days
     * @return
     */
    public static Date addDays(int days) {
        return addDays(new Date(), days);
    }

    /**
     * returns date with added days
     *
     * @param startDate
     * @param days
     * @return
     */
    public static Date addDays(Date startDate, int days) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(startDate);
        cal.add(Calendar.DAY_OF_YEAR, days);
        return cal.getTime();
    }

    /**
     * returns date with added minutes
     *
     * @param startDate
     * @param minutes
     * @return
     */
    public static Date addMinutes(Date startDate, int minutes) {
        Calendar cal = Calendar.getInstance();
        cal.setTime(startDate);
        cal.add(Calendar.MINUTE, minutes);
        return cal.getTime();
    }


    /**
     * returns date with added minutes
     *
     * @param minutes
     * @return
     */
    public static Date addMinutes(int minutes) {
        return addMinutes(new Date(), minutes);
    }


    /**
     * Return todays date without time
     *
     * @return
     */
    public static Date shortNow() {
        return truncate(new Date());
    }

    /**
     * Returns true if provided date has it's place before today (without time)
     *
     * @param dateToCheck
     * @return
     */
    public static Boolean beforeToday(Date dateToCheck) {
        return (truncate(dateToCheck).before(shortNow()));
    }


    /**
     * Returns true if provided date has it's place in the future
     *
     * @param dateToCheck
     * @return
     */
    public static Boolean inTheFuture(Date dateToCheck) {
        return (truncate(dateToCheck).after(shortNow()));
    }

    public static Date todayWithHourAndMinutes(int hour, int minute) {
        Date today = shortNow();
        Calendar cal = Calendar.getInstance();
        cal.setTime(today);
        cal.set(cal.get(Calendar.YEAR), cal.get(Calendar.MONTH), cal.get(Calendar.DAY_OF_MONTH), hour, minute, 0);
        return cal.getTime();
    }


    /**
     * check if date is before provided date; all dates will be truncated to "DAY" before comparison
     *
     * @param dateToValidate
     * @param againsStartDate
     * @return
     */
    public static Boolean beforeDateTruncated(Date dateToValidate, Date againsStartDate) {
        return truncate(dateToValidate).before(truncate(againsStartDate));
    }

    /**
     * Check if we add days to current date, it will be after provided date
     *
     * @param dateToValidate
     * @param daysToAdd
     * @return
     */
    public static Boolean afterTodayWithDays(Date dateToValidate, int daysToAdd) {
        return trunacateAndAddDays(shortNow(), daysToAdd).before(dateToValidate);
    }

    /**
     * get current year
     *
     * @return
     */
    public static long getCurrentYear() {
        Calendar now = Calendar.getInstance();
        return now.get(Calendar.YEAR);
    }

    /**
     * create XMLGregorianCalendar based on String object
     *
     * @param date
     * @return
     * @throws DatatypeConfigurationException
     * @throws ParseException
     */
    public static XMLGregorianCalendar xmlGregorianCalendarFromDate(String date) throws DatatypeConfigurationException, ParseException {
        return xmlGregorianCalendarFromDate(date, "yyyy-MM-dd");
    }

    public static XMLGregorianCalendar ibsNullDate() {
        return DateHelper.xmlGregorianCalendarFromDate(nullDate());
    }


    /**
     * create XMLGregorianCalendar based on String object and string pattern
     *
     * @param date
     * @param dateFormat
     * @return
     * @throws DatatypeConfigurationException
     * @throws ParseException
     */
    public static XMLGregorianCalendar xmlGregorianCalendarFromDate(String date, String dateFormat) throws DatatypeConfigurationException, ParseException {
        SimpleDateFormat format = new SimpleDateFormat(dateFormat);
        return xmlGregorianCalendarFromDate(format.parse(date));
    }

    /**
     * create XMLGregorianCalendar based on Date object
     *
     * @param date
     * @return
     * @throws DatatypeConfigurationException
     */
    public static XMLGregorianCalendar xmlGregorianCalendarFromDate(Date date) {
        try {
            if (date == null) {
                return emptyXmlGregorianCalendar();
            }
            GregorianCalendar calendar = new GregorianCalendar();
            calendar.setTime(date);
            return DatatypeFactory.newInstance().newXMLGregorianCalendar(calendar);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * get formatted XMLGregorianCalendar based on simple string
     *
     * @param date
     * @return
     * @throws DatatypeConfigurationException
     */
    public static XMLGregorianCalendar xmlGregorianCalendarSimple(String date, String dateFormat) throws DatatypeConfigurationException, ParseException {
        SimpleDateFormat format = new SimpleDateFormat(dateFormat);
        Date parsed = format.parse(date);

        return xmlGregorianCalendarSimple(parsed);
    }

    /**
     * get formatted XMLGregorianCalendar
     *
     * @param date
     * @return
     * @throws DatatypeConfigurationException
     */
    public static XMLGregorianCalendar xmlGregorianCalendarSimple(Date date) throws DatatypeConfigurationException {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.setTime(date);

        return DatatypeFactory.newInstance().newXMLGregorianCalendarDate(
                calendar.get(Calendar.YEAR),
                calendar.get(Calendar.MONTH) + 1,
                calendar.get(Calendar.DAY_OF_MONTH),
                DatatypeConstants.FIELD_UNDEFINED
        );
    }

    /**
     * just return empty date
     *
     * @return
     * @throws DatatypeConfigurationException
     */
    public static XMLGregorianCalendar emptyXmlGregorianCalendar() throws DatatypeConfigurationException {
        GregorianCalendar calendar = new GregorianCalendar();
        calendar.set(1000, 0, 1, 0, 0, 0);
        calendar.set(Calendar.MILLISECOND, 0);

        return DatatypeFactory.newInstance().newXMLGregorianCalendar(calendar);
    }


    public static long daysBetween(Date fromDate, Date toDate) {
        return ChronoUnit.DAYS.between(fromDate.toInstant(), toDate.toInstant());
    }

    /**
     * get years amount between two dates
     *
     * @param fromDate
     * @param toDate
     * @return
     */
    public static int yearsBetween(Date fromDate, Date toDate) {
        DateTime from = new DateTime(fromDate.getTime());
        DateTime to = new DateTime(toDate.getTime());

        return Years.yearsBetween(from, to).getYears();
    }


    public static Date nullDate() {
        return null;
    }

    public static long currentYear() {
        Date date = new Date();
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(date);
        return calendar.get(Calendar.YEAR);
    }


    /**
     * calculate age of a vehicle, that is round up (eg if its 5 years 3 months, it will be 6 years)
     *
     * @param firstRegistration     date of first registration
     * @param insuranceStartingDate starting date of insurance
     * @return
     */
    public static long vehicleAge(Date firstRegistration, Date insuranceStartingDate) {
        Date d = addDays(insuranceStartingDate, -1);
        return ageInYears(firstRegistration, d) + 1;
    }
}