org.opentripplanner.framework.time.DateUtils Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of otp Show documentation
The OpenTripPlanner multimodal journey planning system
The newest version!
package org.opentripplanner.framework.time;

import java.time.Duration;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.List;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * @author Frank Purcell (p u r c e l l f @ t r i m e t . o r g) October 20, 2009
 */
public class DateUtils {

  private static final Logger LOG = LoggerFactory.getLogger(DateUtils.class);

  private static final int SANITY_CHECK_CUTOFF_YEAR = 1000;

  // NOTE: don't change the order of these strings...the simplest should be on the
  // bottom...you risk parsing the wrong thing (and ending up with year 0012)
  private static final List DF_LIST = List.of(
    DateTimeFormatter.ofPattern("yyyy.MM.dd.HH.mm.ss"),
    DateTimeFormatter.ofPattern("yyyy.MM.dd.HH.mm"),
    DateTimeFormatter.ofPattern("yyyy.MM.dd.HH.mm.ss.SS"),
    DateTimeFormatter.ofPattern("M.d.yy h.mm a"),
    DateTimeFormatter.ofPattern("M.d.yyyy h.mm a"),
    DateTimeFormatter.ofPattern("M.d.yyyy h.mma"),
    DateTimeFormatter.ofPattern("M.d.yyyy h.mm"),
    DateTimeFormatter.ofPattern("M.d.yyyy k.mm"),
    DateTimeFormatter.ofPattern("M.d.yyyy"),
    DateTimeFormatter.ofPattern("yyyy.M.d"),
    DateTimeFormatter.ofPattern("h.mm a")
    // NOTE: don't change the order of these strings...the simplest should be on the
    // bottom...you risk parsing the wrong thing (and ending up with year 0012)
  );

  private static final List SMALL_DF_LIST = List.of(
    DateTimeFormatter.ofPattern("M.d.yy"),
    DateTimeFormatter.ofPattern("yy.M.d"),
    DateTimeFormatter.ofPattern("h.mm a")
  );

  /**
   * Returns a Date object based on input date and time parameters Defaults to today / now (when
   * date / time are null)
   */
  @Nullable
  public static ZonedDateTime toZonedDateTime(String date, String time, ZoneId tz) {
    //LOG.debug("JVM default timezone is {}", TimeZone.getDefault());
    LOG.debug("Parsing date {} and time {}", date, time);
    LOG.debug("using timezone {}", tz);
    ZonedDateTime retVal = ZonedDateTime.ofInstant(Instant.now(), tz);
    if (date != null) {
      LocalDate localDate = parseDate(date);
      if (localDate == null) {
        return null; //unparseable date
      }
      boolean timed = false;
      if (time != null) {
        LocalTime localTime = parseTime(time);
        if (localTime != null) {
          retVal = LocalDateTime.of(localDate, localTime).atZone(tz);
          timed = true;
        }
      }
      if (!timed) {
        //assume t = now
        retVal = LocalDateTime.of(localDate, retVal.toLocalTime()).atZone(tz);
      }
    } else if (time != null) {
      LocalTime localTime = parseTime(time);
      if (localTime != null) {
        retVal = LocalDateTime.of(retVal.toLocalDate(), localTime).atZone(tz);
      }
    }
    LOG.debug("resulting date is {}", retVal);
    return retVal;
  }

  // TODO: could be replaced with Apache's DateFormat.parseDate ???
  public static LocalDate parseDate(@Nonnull String input) {
    LocalDate retVal = null;
    try {
      String newString = input
        .trim()
        .replace('_', '.')
        .replace('-', '.')
        .replace(':', '.')
        .replace('/', '.');
      List dateTimeFormatterList = DF_LIST;

      if (newString.length() <= 8) {
        if (newString.matches("\\d\\d\\d\\d\\d\\d\\d\\d")) {
          // Accept dates without punctuation if they consist of exactly eight digits.
          newString =
            newString.substring(0, 4) +
            '.' +
            newString.substring(4, 6) +
            '.' +
            newString.substring(6, 8);
        } else if (!(newString.matches(".*20\\d\\d.*"))) {
          // if it looks like we have a small date format, ala 11.4.09, then use
          // another set of compares
          dateTimeFormatterList = SMALL_DF_LIST;
        }
      }

      for (DateTimeFormatter dateTimeFormatter : dateTimeFormatterList) {
        try {
          retVal = LocalDate.parse(newString, dateTimeFormatter);
          if (retVal != null) {
            int year = retVal.getYear();
            if (year >= SANITY_CHECK_CUTOFF_YEAR) {
              break;
            }
          }
        } catch (DateTimeParseException ex) {}
      }
    } catch (Exception ex) {
      throw new RuntimeException("Could not parse " + input);
    }

    return retVal;
  }

  public static int getIntegerFromString(String input) {
    try {
      return Integer.parseInt(input);
    } catch (Exception e) {
      return 0;
    }
  }

  /**
   * Converts the given time in seconds to a String in the format h:mm.
   *
   * @param seconds the time in seconds.
   * @return a String representing the time in the format h:mm
   */
  public static String secToHHMM(int seconds) {
    int min;
    String sign = "";

    if (seconds >= 0) {
      min = seconds / 60;
      sign = "";
    } else {
      min = -seconds / 60;
      sign = "-";
    }

    int mm = min % 60;
    int hh = min / 60;

    return String.format("%s%d:%02d", sign, hh, mm);
  }

  public static String trim(String str) {
    String retVal = str;
    try {
      retVal = str.trim();
      retVal = retVal.replaceAll("%20;", "");
      retVal = retVal.replaceAll("%20", "");
    } catch (Exception ex) {}
    return retVal;
  }

  public static long absoluteTimeout(Duration timeout) {
    if (timeout == null) {
      return Long.MAX_VALUE;
    } else {
      return System.currentTimeMillis() + timeout.toMillis();
    }
  }

  /**
   * Parse a time string on different formats:
   *
   *    * Hour Minute Second      "10:02:03"
   * Hour Minute             "10:02"
   * Seconds past midningt   "3600"
   * AM / PM                 "11:30 PM"
   * 
   */
  @Nullable
  public static LocalTime parseTime(String time) {
    boolean amPm = false;
    int addHours = 0;
    int hour = 0, min = 0, sec = 0;
    try {
      String[] hms = time.toUpperCase().split(":");

      // if we don't have a colon sep string, assume string is int and represents seconds past
      // midnight
      if (hms.length < 2) {
        return LocalTime.ofSecondOfDay(getIntegerFromString(time));
      }

      if (hms[1].endsWith("PM") || hms[1].endsWith("AM")) {
        amPm = true;

        if (hms[1].contains("PM")) addHours = 12;

        int suffex = hms[1].lastIndexOf(' ');
        if (suffex < 1) {
          suffex = hms[1].lastIndexOf("AM");
          if (suffex < 1) {
            suffex = hms[1].lastIndexOf("PM");
          }
        }
        hms[1] = hms[1].substring(0, suffex);
      }

      int h = Integer.parseInt(trim(hms[0]));
      if (amPm && h == 12) h = 0;
      hour = h + addHours;

      min = Integer.parseInt(trim(hms[1]));
      if (hms.length > 2) {
        sec = Integer.parseInt(trim(hms[2]));
      }

      return LocalTime.of(hour, min, sec);
    } catch (Exception ignore) {
      LOG.info("Time '{}' didn't parse", time);
      return null;
    }
  }
}