Example usage for org.joda.time.format ISODateTimeFormat basicDate

Introduction

In this page you can find the example usage for org.joda.time.format ISODateTimeFormat basicDate.

Prototype

public static DateTimeFormatter basicDate() 

Source Link

Document

Returns a basic formatter for a full date as four digit year, two digit month of year, and two digit day of month (yyyyMMdd).

Usage

From source file:org.apigw.authserver.svc.impl.ResidentServicesImpl.java

License:Open Source License

private boolean isOverAgeLimit(String childIdNumber) {
    final String dateOfBirthString = childIdNumber.substring(0, 8);
    final DateTime dateOfBirth = DateTime.parse(dateOfBirthString, ISODateTimeFormat.basicDate());

    return yearsBetween(dateOfBirth, now()).isGreaterThan(years(legalGuradianAgeLimit));
}

---

From source file:org.apigw.authserver.svc.impl.TokenServicesImpl.java

License:Open Source License

/**
 * @param residentIdentificationNumber in format yyyyMMddnnnn- for example 199212319876
 * @param validitySeconds - for example 43200  (60 * 60 * 12) - 12 hours in the future
 * @return/*  ww w .j av  a 2s  . co m*/
 */
protected Date generateExpirationTime(String residentIdentificationNumber, long validitySeconds) {
    if (residentIdentificationNumber == null || residentIdentificationNumber.length() < 8) {
        throw new IllegalArgumentException(
                "Invalid residentIdentificationNumber " + residentIdentificationNumber);
    }
    long validityMilliseconds = validitySeconds * 1000L;
    final String birthdayString = residentIdentificationNumber.substring(0, 8);
    final DateTime birthDate = DateTime.parse(birthdayString, ISODateTimeFormat.basicDate());
    Period period = new Period(birthDate, new DateTime(), PeriodType.yearMonthDay());
    DateTime birthDatePlusLegalGuardianAgeLimit = birthDate.plusYears(legalGuardianAgeLimit);
    DateTime residentAdultDate = birthDate.plusYears(adultAge);
    DateTime expiration = new DateTime().withTimeAtStartOfDay(); //defaulting to midnight of today (token will be immediately invalid)
    if (validitySeconds > 0) {
        // Standard expiration
        final DateTime standardExpiration = new DateTime().plus(validityMilliseconds);
        if (birthDatePlusLegalGuardianAgeLimit.isAfter(now().plus(validityMilliseconds))) { // resident will hit the legal guardian age after max token validity
            expiration = standardExpiration;
        } else if (residentAdultDate.isBeforeNow()) { // resident is considered adult
            expiration = standardExpiration;
        } else if (birthDatePlusLegalGuardianAgeLimit.isAfterNow()) { //resident will hit the legal guardian age before max token validity
            expiration = birthDatePlusLegalGuardianAgeLimit;
        }
        // if we get here resident has passed legal guardian age but is not considered adult, using default
    }
    log.debug("calculated token exp time for resident who is ~ {} years, {} months and {} days old to {}",
            period.getYears(), period.getMonths(), period.getDays(), expiration);
    return expiration.toDate();
}

---

From source file:org.codelibs.elasticsearch.common.joda.Joda.java

License:Apache License

/**
 * Parses a joda based pattern, including some named ones (similar to the built in Joda ISO ones).
 *///from w w w .  j a  v  a  2 s  .  c  o m
public static FormatDateTimeFormatter forPattern(String input, Locale locale) {
    if (Strings.hasLength(input)) {
        input = input.trim();
    }
    if (input == null || input.length() == 0) {
        throw new IllegalArgumentException("No date pattern provided");
    }

    DateTimeFormatter formatter;
    if ("basicDate".equals(input) || "basic_date".equals(input)) {
        formatter = ISODateTimeFormat.basicDate();
    } else if ("basicDateTime".equals(input) || "basic_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicDateTime();
    } else if ("basicDateTimeNoMillis".equals(input) || "basic_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicDateTimeNoMillis();
    } else if ("basicOrdinalDate".equals(input) || "basic_ordinal_date".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDate();
    } else if ("basicOrdinalDateTime".equals(input) || "basic_ordinal_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDateTime();
    } else if ("basicOrdinalDateTimeNoMillis".equals(input)
            || "basic_ordinal_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDateTimeNoMillis();
    } else if ("basicTime".equals(input) || "basic_time".equals(input)) {
        formatter = ISODateTimeFormat.basicTime();
    } else if ("basicTimeNoMillis".equals(input) || "basic_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicTimeNoMillis();
    } else if ("basicTTime".equals(input) || "basic_t_Time".equals(input)) {
        formatter = ISODateTimeFormat.basicTTime();
    } else if ("basicTTimeNoMillis".equals(input) || "basic_t_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicTTimeNoMillis();
    } else if ("basicWeekDate".equals(input) || "basic_week_date".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDate();
    } else if ("basicWeekDateTime".equals(input) || "basic_week_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDateTime();
    } else if ("basicWeekDateTimeNoMillis".equals(input) || "basic_week_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDateTimeNoMillis();
    } else if ("date".equals(input)) {
        formatter = ISODateTimeFormat.date();
    } else if ("dateHour".equals(input) || "date_hour".equals(input)) {
        formatter = ISODateTimeFormat.dateHour();
    } else if ("dateHourMinute".equals(input) || "date_hour_minute".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinute();
    } else if ("dateHourMinuteSecond".equals(input) || "date_hour_minute_second".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecond();
    } else if ("dateHourMinuteSecondFraction".equals(input)
            || "date_hour_minute_second_fraction".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecondFraction();
    } else if ("dateHourMinuteSecondMillis".equals(input) || "date_hour_minute_second_millis".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecondMillis();
    } else if ("dateOptionalTime".equals(input) || "date_optional_time".equals(input)) {
        // in this case, we have a separate parser and printer since the dataOptionalTimeParser can't print
        // this sucks we should use the root local by default and not be dependent on the node
        return new FormatDateTimeFormatter(input,
                ISODateTimeFormat.dateOptionalTimeParser().withZone(DateTimeZone.UTC),
                ISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC), locale);
    } else if ("dateTime".equals(input) || "date_time".equals(input)) {
        formatter = ISODateTimeFormat.dateTime();
    } else if ("dateTimeNoMillis".equals(input) || "date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.dateTimeNoMillis();
    } else if ("hour".equals(input)) {
        formatter = ISODateTimeFormat.hour();
    } else if ("hourMinute".equals(input) || "hour_minute".equals(input)) {
        formatter = ISODateTimeFormat.hourMinute();
    } else if ("hourMinuteSecond".equals(input) || "hour_minute_second".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecond();
    } else if ("hourMinuteSecondFraction".equals(input) || "hour_minute_second_fraction".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecondFraction();
    } else if ("hourMinuteSecondMillis".equals(input) || "hour_minute_second_millis".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecondMillis();
    } else if ("ordinalDate".equals(input) || "ordinal_date".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDate();
    } else if ("ordinalDateTime".equals(input) || "ordinal_date_time".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDateTime();
    } else if ("ordinalDateTimeNoMillis".equals(input) || "ordinal_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDateTimeNoMillis();
    } else if ("time".equals(input)) {
        formatter = ISODateTimeFormat.time();
    } else if ("timeNoMillis".equals(input) || "time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.timeNoMillis();
    } else if ("tTime".equals(input) || "t_time".equals(input)) {
        formatter = ISODateTimeFormat.tTime();
    } else if ("tTimeNoMillis".equals(input) || "t_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.tTimeNoMillis();
    } else if ("weekDate".equals(input) || "week_date".equals(input)) {
        formatter = ISODateTimeFormat.weekDate();
    } else if ("weekDateTime".equals(input) || "week_date_time".equals(input)) {
        formatter = ISODateTimeFormat.weekDateTime();
    } else if ("weekDateTimeNoMillis".equals(input) || "week_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.weekDateTimeNoMillis();
    } else if ("weekyear".equals(input) || "week_year".equals(input)) {
        formatter = ISODateTimeFormat.weekyear();
    } else if ("weekyearWeek".equals(input) || "weekyear_week".equals(input)) {
        formatter = ISODateTimeFormat.weekyearWeek();
    } else if ("weekyearWeekDay".equals(input) || "weekyear_week_day".equals(input)) {
        formatter = ISODateTimeFormat.weekyearWeekDay();
    } else if ("year".equals(input)) {
        formatter = ISODateTimeFormat.year();
    } else if ("yearMonth".equals(input) || "year_month".equals(input)) {
        formatter = ISODateTimeFormat.yearMonth();
    } else if ("yearMonthDay".equals(input) || "year_month_day".equals(input)) {
        formatter = ISODateTimeFormat.yearMonthDay();
    } else if ("epoch_second".equals(input)) {
        formatter = new DateTimeFormatterBuilder()
                .append(new EpochTimePrinter(false), new EpochTimeParser(false)).toFormatter();
    } else if ("epoch_millis".equals(input)) {
        formatter = new DateTimeFormatterBuilder().append(new EpochTimePrinter(true), new EpochTimeParser(true))
                .toFormatter();
        // strict date formats here, must be at least 4 digits for year and two for months and two for day
    } else if ("strictBasicWeekDate".equals(input) || "strict_basic_week_date".equals(input)) {
        formatter = StrictISODateTimeFormat.basicWeekDate();
    } else if ("strictBasicWeekDateTime".equals(input) || "strict_basic_week_date_time".equals(input)) {
        formatter = StrictISODateTimeFormat.basicWeekDateTime();
    } else if ("strictBasicWeekDateTimeNoMillis".equals(input)
            || "strict_basic_week_date_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.basicWeekDateTimeNoMillis();
    } else if ("strictDate".equals(input) || "strict_date".equals(input)) {
        formatter = StrictISODateTimeFormat.date();
    } else if ("strictDateHour".equals(input) || "strict_date_hour".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHour();
    } else if ("strictDateHourMinute".equals(input) || "strict_date_hour_minute".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHourMinute();
    } else if ("strictDateHourMinuteSecond".equals(input) || "strict_date_hour_minute_second".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHourMinuteSecond();
    } else if ("strictDateHourMinuteSecondFraction".equals(input)
            || "strict_date_hour_minute_second_fraction".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHourMinuteSecondFraction();
    } else if ("strictDateHourMinuteSecondMillis".equals(input)
            || "strict_date_hour_minute_second_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.dateHourMinuteSecondMillis();
    } else if ("strictDateOptionalTime".equals(input) || "strict_date_optional_time".equals(input)) {
        // in this case, we have a separate parser and printer since the dataOptionalTimeParser can't print
        // this sucks we should use the root local by default and not be dependent on the node
        return new FormatDateTimeFormatter(input,
                StrictISODateTimeFormat.dateOptionalTimeParser().withZone(DateTimeZone.UTC),
                StrictISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC), locale);
    } else if ("strictDateTime".equals(input) || "strict_date_time".equals(input)) {
        formatter = StrictISODateTimeFormat.dateTime();
    } else if ("strictDateTimeNoMillis".equals(input) || "strict_date_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.dateTimeNoMillis();
    } else if ("strictHour".equals(input) || "strict_hour".equals(input)) {
        formatter = StrictISODateTimeFormat.hour();
    } else if ("strictHourMinute".equals(input) || "strict_hour_minute".equals(input)) {
        formatter = StrictISODateTimeFormat.hourMinute();
    } else if ("strictHourMinuteSecond".equals(input) || "strict_hour_minute_second".equals(input)) {
        formatter = StrictISODateTimeFormat.hourMinuteSecond();
    } else if ("strictHourMinuteSecondFraction".equals(input)
            || "strict_hour_minute_second_fraction".equals(input)) {
        formatter = StrictISODateTimeFormat.hourMinuteSecondFraction();
    } else if ("strictHourMinuteSecondMillis".equals(input)
            || "strict_hour_minute_second_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.hourMinuteSecondMillis();
    } else if ("strictOrdinalDate".equals(input) || "strict_ordinal_date".equals(input)) {
        formatter = StrictISODateTimeFormat.ordinalDate();
    } else if ("strictOrdinalDateTime".equals(input) || "strict_ordinal_date_time".equals(input)) {
        formatter = StrictISODateTimeFormat.ordinalDateTime();
    } else if ("strictOrdinalDateTimeNoMillis".equals(input)
            || "strict_ordinal_date_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.ordinalDateTimeNoMillis();
    } else if ("strictTime".equals(input) || "strict_time".equals(input)) {
        formatter = StrictISODateTimeFormat.time();
    } else if ("strictTimeNoMillis".equals(input) || "strict_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.timeNoMillis();
    } else if ("strictTTime".equals(input) || "strict_t_time".equals(input)) {
        formatter = StrictISODateTimeFormat.tTime();
    } else if ("strictTTimeNoMillis".equals(input) || "strict_t_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.tTimeNoMillis();
    } else if ("strictWeekDate".equals(input) || "strict_week_date".equals(input)) {
        formatter = StrictISODateTimeFormat.weekDate();
    } else if ("strictWeekDateTime".equals(input) || "strict_week_date_time".equals(input)) {
        formatter = StrictISODateTimeFormat.weekDateTime();
    } else if ("strictWeekDateTimeNoMillis".equals(input) || "strict_week_date_time_no_millis".equals(input)) {
        formatter = StrictISODateTimeFormat.weekDateTimeNoMillis();
    } else if ("strictWeekyear".equals(input) || "strict_weekyear".equals(input)) {
        formatter = StrictISODateTimeFormat.weekyear();
    } else if ("strictWeekyearWeek".equals(input) || "strict_weekyear_week".equals(input)) {
        formatter = StrictISODateTimeFormat.weekyearWeek();
    } else if ("strictWeekyearWeekDay".equals(input) || "strict_weekyear_week_day".equals(input)) {
        formatter = StrictISODateTimeFormat.weekyearWeekDay();
    } else if ("strictYear".equals(input) || "strict_year".equals(input)) {
        formatter = StrictISODateTimeFormat.year();
    } else if ("strictYearMonth".equals(input) || "strict_year_month".equals(input)) {
        formatter = StrictISODateTimeFormat.yearMonth();
    } else if ("strictYearMonthDay".equals(input) || "strict_year_month_day".equals(input)) {
        formatter = StrictISODateTimeFormat.yearMonthDay();
    } else if (Strings.hasLength(input) && input.contains("||")) {
        String[] formats = Strings.delimitedListToStringArray(input, "||");
        DateTimeParser[] parsers = new DateTimeParser[formats.length];

        if (formats.length == 1) {
            formatter = forPattern(input, locale).parser();
        } else {
            DateTimeFormatter dateTimeFormatter = null;
            for (int i = 0; i < formats.length; i++) {
                FormatDateTimeFormatter currentFormatter = forPattern(formats[i], locale);
                DateTimeFormatter currentParser = currentFormatter.parser();
                if (dateTimeFormatter == null) {
                    dateTimeFormatter = currentFormatter.printer();
                }
                parsers[i] = currentParser.getParser();
            }

            DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder()
                    .append(dateTimeFormatter.withZone(DateTimeZone.UTC).getPrinter(), parsers);
            formatter = builder.toFormatter();
        }
    } else {
        try {
            formatter = DateTimeFormat.forPattern(input);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid format: [" + input + "]: " + e.getMessage(), e);
        }
    }

    return new FormatDateTimeFormatter(input, formatter.withZone(DateTimeZone.UTC), locale);
}

---

From source file:org.elasticsearch.common.joda.Joda.java

License:Apache License

/**
 * Parses a joda based pattern, including some named ones (similar to the built in Joda ISO ones).
 *//*from w ww. ja v  a2s .  com*/
public static FormatDateTimeFormatter forPattern(String input, Locale locale) {
    if (Strings.hasLength(input)) {
        input = input.trim();
    }
    if (input == null || input.length() == 0) {
        throw new IllegalArgumentException("No date pattern provided");
    }

    DateTimeFormatter formatter;
    if ("basicDate".equals(input) || "basic_date".equals(input)) {
        formatter = ISODateTimeFormat.basicDate();
    } else if ("basicDateTime".equals(input) || "basic_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicDateTime();
    } else if ("basicDateTimeNoMillis".equals(input) || "basic_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicDateTimeNoMillis();
    } else if ("basicOrdinalDate".equals(input) || "basic_ordinal_date".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDate();
    } else if ("basicOrdinalDateTime".equals(input) || "basic_ordinal_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDateTime();
    } else if ("basicOrdinalDateTimeNoMillis".equals(input)
            || "basic_ordinal_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDateTimeNoMillis();
    } else if ("basicTime".equals(input) || "basic_time".equals(input)) {
        formatter = ISODateTimeFormat.basicTime();
    } else if ("basicTimeNoMillis".equals(input) || "basic_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicTimeNoMillis();
    } else if ("basicTTime".equals(input) || "basic_t_Time".equals(input)) {
        formatter = ISODateTimeFormat.basicTTime();
    } else if ("basicTTimeNoMillis".equals(input) || "basic_t_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicTTimeNoMillis();
    } else if ("basicWeekDate".equals(input) || "basic_week_date".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDate();
    } else if ("basicWeekDateTime".equals(input) || "basic_week_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDateTime();
    } else if ("basicWeekDateTimeNoMillis".equals(input) || "basic_week_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDateTimeNoMillis();
    } else if ("date".equals(input)) {
        formatter = ISODateTimeFormat.date();
    } else if ("dateHour".equals(input) || "date_hour".equals(input)) {
        formatter = ISODateTimeFormat.dateHour();
    } else if ("dateHourMinute".equals(input) || "date_hour_minute".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinute();
    } else if ("dateHourMinuteSecond".equals(input) || "date_hour_minute_second".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecond();
    } else if ("dateHourMinuteSecondFraction".equals(input)
            || "date_hour_minute_second_fraction".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecondFraction();
    } else if ("dateHourMinuteSecondMillis".equals(input) || "date_hour_minute_second_millis".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecondMillis();
    } else if ("dateOptionalTime".equals(input) || "date_optional_time".equals(input)) {
        // in this case, we have a separate parser and printer since the dataOptionalTimeParser can't print
        // this sucks we should use the root local by default and not be dependent on the node
        return new FormatDateTimeFormatter(input,
                ISODateTimeFormat.dateOptionalTimeParser().withZone(DateTimeZone.UTC),
                ISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC), locale);
    } else if ("dateTime".equals(input) || "date_time".equals(input)) {
        formatter = ISODateTimeFormat.dateTime();
    } else if ("dateTimeNoMillis".equals(input) || "date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.dateTimeNoMillis();
    } else if ("hour".equals(input)) {
        formatter = ISODateTimeFormat.hour();
    } else if ("hourMinute".equals(input) || "hour_minute".equals(input)) {
        formatter = ISODateTimeFormat.hourMinute();
    } else if ("hourMinuteSecond".equals(input) || "hour_minute_second".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecond();
    } else if ("hourMinuteSecondFraction".equals(input) || "hour_minute_second_fraction".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecondFraction();
    } else if ("hourMinuteSecondMillis".equals(input) || "hour_minute_second_millis".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecondMillis();
    } else if ("ordinalDate".equals(input) || "ordinal_date".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDate();
    } else if ("ordinalDateTime".equals(input) || "ordinal_date_time".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDateTime();
    } else if ("ordinalDateTimeNoMillis".equals(input) || "ordinal_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDateTimeNoMillis();
    } else if ("time".equals(input)) {
        formatter = ISODateTimeFormat.time();
    } else if ("tTime".equals(input) || "t_time".equals(input)) {
        formatter = ISODateTimeFormat.tTime();
    } else if ("tTimeNoMillis".equals(input) || "t_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.tTimeNoMillis();
    } else if ("weekDate".equals(input) || "week_date".equals(input)) {
        formatter = ISODateTimeFormat.weekDate();
    } else if ("weekDateTime".equals(input) || "week_date_time".equals(input)) {
        formatter = ISODateTimeFormat.weekDateTime();
    } else if ("weekyear".equals(input) || "week_year".equals(input)) {
        formatter = ISODateTimeFormat.weekyear();
    } else if ("weekyearWeek".equals(input)) {
        formatter = ISODateTimeFormat.weekyearWeek();
    } else if ("year".equals(input)) {
        formatter = ISODateTimeFormat.year();
    } else if ("yearMonth".equals(input) || "year_month".equals(input)) {
        formatter = ISODateTimeFormat.yearMonth();
    } else if ("yearMonthDay".equals(input) || "year_month_day".equals(input)) {
        formatter = ISODateTimeFormat.yearMonthDay();
    } else if (Strings.hasLength(input) && input.contains("||")) {
        String[] formats = Strings.delimitedListToStringArray(input, "||");
        DateTimeParser[] parsers = new DateTimeParser[formats.length];

        if (formats.length == 1) {
            formatter = forPattern(input, locale).parser();
        } else {
            DateTimeFormatter dateTimeFormatter = null;
            for (int i = 0; i < formats.length; i++) {
                DateTimeFormatter currentFormatter = forPattern(formats[i], locale).parser();
                if (dateTimeFormatter == null) {
                    dateTimeFormatter = currentFormatter;
                }
                parsers[i] = currentFormatter.getParser();
            }

            DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder()
                    .append(dateTimeFormatter.withZone(DateTimeZone.UTC).getPrinter(), parsers);
            formatter = builder.toFormatter();
        }
    } else {
        try {
            formatter = DateTimeFormat.forPattern(input);
        } catch (IllegalArgumentException e) {
            throw new IllegalArgumentException("Invalid format: [" + input + "]: " + e.getMessage(), e);
        }
    }

    return new FormatDateTimeFormatter(input, formatter.withZone(DateTimeZone.UTC), locale);
}

---

From source file:org.elasticsearch.common.xcontent.BaseXContentTestCase.java

License:Apache License

public void testReadableInstant() throws Exception {
    assertResult("{'instant':null}",
            () -> builder().startObject().field("instant", (ReadableInstant) null).endObject());
    assertResult("{'instant':null}",
            () -> builder().startObject().field("instant").value((ReadableInstant) null).endObject());

    final DateTime t1 = new DateTime(2016, 1, 1, 0, 0, DateTimeZone.UTC);

    String expected = "{'t1':'2016-01-01T00:00:00.000Z'}";
    assertResult(expected, () -> builder().startObject().field("t1", t1).endObject());
    assertResult(expected, () -> builder().startObject().field("t1").value(t1).endObject());

    final DateTime t2 = new DateTime(2016, 12, 25, 7, 59, 42, 213, DateTimeZone.UTC);

    expected = "{'t2':'2016-12-25T07:59:42.213Z'}";
    assertResult(expected, () -> builder().startObject().field("t2", t2).endObject());
    assertResult(expected, () -> builder().startObject().field("t2").value(t2).endObject());

    final DateTimeFormatter formatter = randomFrom(ISODateTimeFormat.basicDate(),
            ISODateTimeFormat.dateTimeNoMillis());
    final DateTime t3 = DateTime.now();

    expected = "{'t3':'" + formatter.print(t3) + "'}";
    assertResult(expected, () -> builder().startObject().field("t3", t3, formatter).endObject());
    assertResult(expected, () -> builder().startObject().field("t3").value(t3, formatter).endObject());

    final DateTime t4 = new DateTime(randomDateTimeZone());

    expected = "{'t4':'" + formatter.print(t4) + "'}";
    assertResult(expected, () -> builder().startObject().field("t4", t4, formatter).endObject());
    assertResult(expected, () -> builder().startObject().field("t4").value(t4, formatter).endObject());

    long date = Math.abs(randomLong() % (2 * (long) 10e11)); // 1970-01-01T00:00:00Z - 2033-05-18T05:33:20.000+02:00
    final DateTime t5 = new DateTime(date, randomDateTimeZone());

    expected = "{'t5':'" + XContentBuilder.DEFAULT_DATE_PRINTER.print(t5) + "'}";
    assertResult(expected, () -> builder().startObject().field("t5", t5).endObject());
    assertResult(expected, () -> builder().startObject().field("t5").value(t5).endObject());

    expected = "{'t5':'" + formatter.print(t5) + "'}";
    assertResult(expected, () -> builder().startObject().field("t5", t5, formatter).endObject());
    assertResult(expected, () -> builder().startObject().field("t5").value(t5, formatter).endObject());

    Instant i1 = new Instant(1451606400000L); // 2016-01-01T00:00:00.000Z
    expected = "{'i1':'2016-01-01T00:00:00.000Z'}";
    assertResult(expected, () -> builder().startObject().field("i1", i1).endObject());
    assertResult(expected, () -> builder().startObject().field("i1").value(i1).endObject());

    Instant i2 = new Instant(1482652782213L); // 2016-12-25T07:59:42.213Z
    expected = "{'i2':'" + formatter.print(i2) + "'}";
    assertResult(expected, () -> builder().startObject().field("i2", i2, formatter).endObject());
    assertResult(expected, () -> builder().startObject().field("i2").value(i2, formatter).endObject());

    expectNonNullFormatterException(() -> builder().startObject().field("t3", t3, null).endObject());
    expectNonNullFormatterException(() -> builder().startObject().field("t3").value(t3, null).endObject());
}

---

From source file:org.elasticsearch.common.xcontent.BaseXContentTestCase.java

License:Apache License

public void testDate() throws Exception {
    assertResult("{'date':null}", () -> builder().startObject().field("date", (Date) null).endObject());
    assertResult("{'date':null}", () -> builder().startObject().field("date").value((Date) null).endObject());

    final Date d1 = new DateTime(2016, 1, 1, 0, 0, DateTimeZone.UTC).toDate();
    assertResult("{'d1':'2016-01-01T00:00:00.000Z'}",
            () -> builder().startObject().field("d1", d1).endObject());
    assertResult("{'d1':'2016-01-01T00:00:00.000Z'}",
            () -> builder().startObject().field("d1").value(d1).endObject());

    final Date d2 = new DateTime(2016, 12, 25, 7, 59, 42, 213, DateTimeZone.UTC).toDate();
    assertResult("{'d2':'2016-12-25T07:59:42.213Z'}",
            () -> builder().startObject().field("d2", d2).endObject());
    assertResult("{'d2':'2016-12-25T07:59:42.213Z'}",
            () -> builder().startObject().field("d2").value(d2).endObject());

    final DateTimeFormatter formatter = randomFrom(ISODateTimeFormat.basicDate(),
            ISODateTimeFormat.dateTimeNoMillis());
    final Date d3 = DateTime.now().toDate();

    String expected = "{'d3':'" + formatter.print(d3.getTime()) + "'}";
    assertResult(expected, () -> builder().startObject().field("d3", d3, formatter).endObject());
    assertResult(expected, () -> builder().startObject().field("d3").value(d3, formatter).endObject());

    expectNonNullFormatterException(() -> builder().startObject().field("d3", d3, null).endObject());
    expectNonNullFormatterException(() -> builder().startObject().field("d3").value(d3, null).endObject());
    expectNonNullFormatterException(() -> builder().value(null, 1L));
}

---

From source file:org.elasticsearch.util.joda.Joda.java

License:Apache License

/**
 * Parses a joda based pattern, including some named ones (similar to the built in Joda ISO ones).
 *///  ww  w  . j  av a2s  .  c om
public static FormatDateTimeFormatter forPattern(String input) {
    DateTimeFormatter formatter;
    if ("basicDate".equals(input) || "basic_date".equals(input)) {
        formatter = ISODateTimeFormat.basicDate();
    } else if ("basicDateTime".equals(input) || "basic_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicDateTime();
    } else if ("basicDateTimeNoMillis".equals(input) || "basic_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicDateTimeNoMillis();
    } else if ("basicOrdinalDate".equals(input) || "basic_ordinal_date".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDate();
    } else if ("basicOrdinalDateTime".equals(input) || "basic_ordinal_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDateTime();
    } else if ("basicOrdinalDateTimeNoMillis".equals(input)
            || "basic_ordinal_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicOrdinalDateTimeNoMillis();
    } else if ("basicTime".equals(input) || "basic_time".equals(input)) {
        formatter = ISODateTimeFormat.basicTime();
    } else if ("basicTimeNoMillis".equals(input) || "basic_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicTimeNoMillis();
    } else if ("basicTTime".equals(input) || "basic_t_Time".equals(input)) {
        formatter = ISODateTimeFormat.basicTTime();
    } else if ("basicTTimeNoMillis".equals(input) || "basic_t_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicTTimeNoMillis();
    } else if ("basicWeekDate".equals(input) || "basic_week_date".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDate();
    } else if ("basicWeekDateTime".equals(input) || "basic_week_date_time".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDateTime();
    } else if ("basicWeekDateTimeNoMillis".equals(input) || "basic_week_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.basicWeekDateTimeNoMillis();
    } else if ("date".equals(input)) {
        formatter = ISODateTimeFormat.date();
    } else if ("dateHour".equals(input) || "date_hour".equals(input)) {
        formatter = ISODateTimeFormat.dateHour();
    } else if ("dateHourMinute".equals(input) || "date_hour_minute".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinute();
    } else if ("dateHourMinuteSecond".equals(input) || "date_hour_minute_second".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecond();
    } else if ("dateHourMinuteSecondFraction".equals(input)
            || "date_hour_minute_second_fraction".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecondFraction();
    } else if ("dateHourMinuteSecondMillis".equals(input) || "date_hour_minute_second_millis".equals(input)) {
        formatter = ISODateTimeFormat.dateHourMinuteSecondMillis();
    } else if ("dateOptionalTime".equals(input) || "date_optional_time".equals(input)) {
        // in this case, we have a separate parser and printer since the dataOptionalTimeParser can't print
        return new FormatDateTimeFormatter(input,
                ISODateTimeFormat.dateOptionalTimeParser().withZone(DateTimeZone.UTC),
                ISODateTimeFormat.dateTime().withZone(DateTimeZone.UTC));
    } else if ("dateTime".equals(input) || "date_time".equals(input)) {
        formatter = ISODateTimeFormat.dateTime();
    } else if ("dateTimeNoMillis".equals(input) || "date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.dateTimeNoMillis();
    } else if ("hour".equals(input)) {
        formatter = ISODateTimeFormat.hour();
    } else if ("hourMinute".equals(input) || "hour_minute".equals(input)) {
        formatter = ISODateTimeFormat.hourMinute();
    } else if ("hourMinuteSecond".equals(input) || "hour_minute_second".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecond();
    } else if ("hourMinuteSecondFraction".equals(input) || "hour_minute_second_fraction".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecondFraction();
    } else if ("hourMinuteSecondMillis".equals(input) || "hour_minute_second_millis".equals(input)) {
        formatter = ISODateTimeFormat.hourMinuteSecondMillis();
    } else if ("ordinalDate".equals(input) || "ordinal_date".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDate();
    } else if ("ordinalDateTime".equals(input) || "ordinal_date_time".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDateTime();
    } else if ("ordinalDateTimeNoMillis".equals(input) || "ordinal_date_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.ordinalDateTimeNoMillis();
    } else if ("time".equals(input)) {
        formatter = ISODateTimeFormat.time();
    } else if ("tTime".equals(input) || "t_time".equals(input)) {
        formatter = ISODateTimeFormat.tTime();
    } else if ("tTimeNoMillis".equals(input) || "t_time_no_millis".equals(input)) {
        formatter = ISODateTimeFormat.tTimeNoMillis();
    } else if ("weekDate".equals(input) || "week_date".equals(input)) {
        formatter = ISODateTimeFormat.weekDate();
    } else if ("weekDateTime".equals(input) || "week_date_time".equals(input)) {
        formatter = ISODateTimeFormat.weekDateTime();
    } else if ("weekyear".equals(input) || "week_year".equals(input)) {
        formatter = ISODateTimeFormat.weekyear();
    } else if ("weekyearWeek".equals(input)) {
        formatter = ISODateTimeFormat.weekyearWeek();
    } else if ("year".equals(input)) {
        formatter = ISODateTimeFormat.year();
    } else if ("yearMonth".equals(input) || "year_month".equals(input)) {
        formatter = ISODateTimeFormat.yearMonth();
    } else if ("yearMonthDay".equals(input) || "year_month_day".equals(input)) {
        formatter = ISODateTimeFormat.yearMonthDay();
    } else {
        formatter = DateTimeFormat.forPattern(input);
    }
    formatter.withZone(DateTimeZone.UTC);
    return new FormatDateTimeFormatter(input, formatter);
}

---

From source file:org.fao.geonet.domain.ISODate.java

License:Open Source License

public static DateTime parseBasicOrFullDateTime(String input1) throws Exception {
    DateTimeFormatter bd = ISODateTimeFormat.basicDate();
    DateTimeFormatter bt = ISODateTimeFormat.basicTime();
    DateTimeFormatter bdt = ISODateTimeFormat.basicDateTime();
    DateTimeFormatter dtp = ISODateTimeFormat.dateTimeParser();
    DateTime idt;/* w w w. j a  va  2 s.  c  om*/
    Matcher matcher;
    if (input1.length() == 8 && !input1.startsWith("T")) {
        idt = bd.parseDateTime(input1);
    } else if (input1.startsWith("T") && !input1.contains(":")) {
        idt = bt.parseDateTime(input1);
    } else if (input1.contains("T") && !input1.contains(":") && !input1.contains("-")) {
        idt = bdt.parseDateTime(input1);
    } else if ((matcher = gsYearMonth.matcher(input1)).matches()) {
        String year = matcher.group(1);
        String month = matcher.group(2);
        String minute = "00";
        String hour = "00";
        String timezone = "Z";
        if (matcher.group(4) != null) {
            minute = matcher.group(5);
            hour = matcher.group(4);
            timezone = matcher.group(6);
        }

        idt = generateDate(year, month, minute, hour, timezone);
    } else if ((matcher = gsYear.matcher(input1)).matches()) {
        String year = matcher.group(1);
        String month = "01";
        String minute = "00";
        String hour = "00";
        String timezone = "Z";
        if (matcher.group(3) != null) {
            minute = matcher.group(4);
            hour = matcher.group(3);
            timezone = matcher.group(5);
        }

        idt = generateDate(year, month, minute, hour, timezone);
    } else if ((matcher = htmlFormat.matcher(input1)).matches()) {
        // Fri Jan 01 2010 00:00:00 GMT+0100 (CET)
        String month = matcher.group(2);
        switch (month) {
        case "Jan":
            month = "1";
            break;
        case "Feb":
            month = "2";
            break;
        case "Mar":
            month = "3";
            break;
        case "Apr":
            month = "4";
            break;
        case "May":
            month = "5";
            break;
        case "Jun":
            month = "6";
            break;
        case "Jul":
            month = "7";
            break;
        case "Aug":
            month = "8";
            break;
        case "Sep":
            month = "9";
            break;
        case "Oct":
            month = "10";
            break;
        case "Nov":
            month = "11";
            break;
        default:
            month = "12";
            break;
        }
        String day = matcher.group(3);
        String year = matcher.group(4);
        String hour = matcher.group(5);
        String minute = matcher.group(6);
        String second = matcher.group(7);
        String timezone = matcher.group(8);

        idt = generateDate(year, month, day, second, minute, hour, timezone);
    } else {
        idt = dtp.parseDateTime(input1);
    }
    return idt;
}

---

From source file:org.fao.geonet.util.JODAISODate.java

License:Open Source License

private static DateTime parseBasicOrFullDateTime(String input1) throws Exception {
    DateTimeFormatter bd = ISODateTimeFormat.basicDate();
    DateTimeFormatter bt = ISODateTimeFormat.basicTime();
    DateTimeFormatter bdt = ISODateTimeFormat.basicDateTime();
    DateTimeFormatter dtp = ISODateTimeFormat.dateTimeParser();
    DateTime idt;/*  ww  w .j a  v  a 2  s.c  o m*/
    if (input1.length() == 8 && !input1.startsWith("T")) {
        idt = bd.parseDateTime(input1);
    } else if (input1.startsWith("T") && !input1.contains(":")) {
        idt = bt.parseDateTime(input1);
    } else if (input1.contains("T") && !input1.contains(":") && !input1.contains("-")) {
        idt = bdt.parseDateTime(input1);
    } else {
        idt = dtp.parseDateTime(input1);
    }
    return idt;
}

---

From source file:org.openehr.rm.datatypes.quantity.datetime.DvDateTimeParser.java

License:LGPL

public static DateTime parseDate(String value) {
    if (value == null) {
        throw new IllegalArgumentException("null value for date");
    }// w  w  w.ja va 2  s.  co  m
    if (!value.matches(EXT_DATE) && !value.matches(BDATE)) {
        throw new IllegalArgumentException("invalid pattern for date: " + value);
    }
    DateTime dt = null;
    if (value.indexOf("-") > 0 || value.length() == 4) {
        try {
            dt = ISODateTimeFormat.dateElementParser().withOffsetParsed().parseDateTime(value);
        } catch (Exception e) {
            throw new IllegalArgumentException("invalid value for extended date: " + value);
        }
    } else {
        int size = analyseDateString(value);
        DateTimeFormatter formatter = null;
        switch (size) {
        case 1:
            formatter = ISODateTimeFormat.year().withOffsetParsed();
            break;
        case 2:
            formatter = DateTimeFormat.forPattern("yyyyMM").withOffsetParsed();
            break;
        case 3:
            formatter = ISODateTimeFormat.basicDate().withOffsetParsed();
            break;
        }
        try {
            dt = formatter.parseDateTime(value);
        } catch (Exception e) {
            throw new IllegalArgumentException("invalid value for basic date: " + value);
        }
    }
    return dt;
}

---

• «
• 1
• 2
• »