Example usage for org.joda.time.format DateTimeFormatterBuilder DateTimeFormatterBuilder

Introduction

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

Prototype

public DateTimeFormatterBuilder() 

Source Link

Document

Creates a DateTimeFormatterBuilder.

Usage

From source file:org.apache.druid.java.util.common.parsers.TimestampParser.java

License:Apache License

private static DateTimeFormatter createAutoParser() {
    final DateTimeFormatter offsetElement = new DateTimeFormatterBuilder().appendTimeZoneOffset("Z", true, 2, 4)
            .toFormatter();//from  w  w w . j a va 2  s  .c o  m

    DateTimeParser timeOrOffset = new DateTimeFormatterBuilder()
            .append(null,
                    new DateTimeParser[] { new DateTimeFormatterBuilder().appendLiteral('T').toParser(),
                            new DateTimeFormatterBuilder().appendLiteral(' ').toParser() })
            .appendOptional(ISODateTimeFormat.timeElementParser().getParser())
            .appendOptional(offsetElement.getParser()).toParser();

    return new DateTimeFormatterBuilder().append(ISODateTimeFormat.dateElementParser())
            .appendOptional(timeOrOffset).toFormatter();
}

---

From source file:org.apache.druid.query.expression.TimestampParseExprMacro.java

License:Apache License

/**
 * Default formatter that parses according to the docs for this method: "If the pattern is not provided, this parses
 * time strings in either ISO8601 or SQL format."
 *//*w  w  w .ja v  a2s .c  o m*/
private static DateTimes.UtcFormatter createDefaultParser(final DateTimeZone timeZone) {
    final DateTimeFormatter offsetElement = new DateTimeFormatterBuilder().appendTimeZoneOffset("Z", true, 2, 4)
            .toFormatter();

    DateTimeParser timeOrOffset = new DateTimeFormatterBuilder()
            .append(null,
                    new DateTimeParser[] { new DateTimeFormatterBuilder().appendLiteral('T').toParser(),
                            new DateTimeFormatterBuilder().appendLiteral(' ').toParser() })
            .appendOptional(ISODateTimeFormat.timeElementParser().getParser())
            .appendOptional(offsetElement.getParser()).toParser();

    return DateTimes.wrapFormatter(new DateTimeFormatterBuilder().append(ISODateTimeFormat.dateElementParser())
            .appendOptional(timeOrOffset).toFormatter().withZone(timeZone));
}

---

From source file:org.apache.hive.common.util.TimestampParser.java

License:Apache License

public TimestampParser(String[] formatStrings) {
    this.formatStrings = formatStrings;

    // create formatter that includes all of the input patterns
    if (formatStrings != null && formatStrings.length > 0) {
        DateTimeParser[] parsers = new DateTimeParser[formatStrings.length];
        for (int idx = 0; idx < formatStrings.length; ++idx) {
            String formatString = formatStrings[idx];
            if (formatString.equalsIgnoreCase(millisFormatString)) {
                // Use milliseconds parser if pattern matches our special-case millis pattern string
                parsers[idx] = new MillisDateFormatParser();
            } else {
                parsers[idx] = DateTimeFormat.forPattern(formatString).getParser();
            }//from ww w.ja v a  2s. com
        }
        fmt = new DateTimeFormatterBuilder().append(null, parsers).toFormatter();
    }
}

---

From source file:org.apereo.portal.portlets.statistics.BaseStatisticsReportController.java

License:Apache License

@InitBinder
public void initBinder(WebDataBinder binder) {
    final DateTimeFormatter formatter = new DateTimeFormatterBuilder().appendPattern("M/d/yyyy").toFormatter();
    binder.registerCustomEditor(DateMidnight.class, new CustomDateMidnightEditor(formatter, false));
}

---

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 ava  2  s .  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 ("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.codelibs.elasticsearch.common.joda.Joda.java

License:Apache License

public static FormatDateTimeFormatter getStrictStandardDateFormatter() {
    // 2014/10/10
    DateTimeFormatter shortFormatter = new DateTimeFormatterBuilder()
            .appendFixedDecimal(DateTimeFieldType.year(), 4).appendLiteral('/')
            .appendFixedDecimal(DateTimeFieldType.monthOfYear(), 2).appendLiteral('/')
            .appendFixedDecimal(DateTimeFieldType.dayOfMonth(), 2).toFormatter().withZoneUTC();

    // 2014/10/10 12:12:12
    DateTimeFormatter longFormatter = new DateTimeFormatterBuilder()
            .appendFixedDecimal(DateTimeFieldType.year(), 4).appendLiteral('/')
            .appendFixedDecimal(DateTimeFieldType.monthOfYear(), 2).appendLiteral('/')
            .appendFixedDecimal(DateTimeFieldType.dayOfMonth(), 2).appendLiteral(' ')
            .appendFixedSignedDecimal(DateTimeFieldType.hourOfDay(), 2).appendLiteral(':')
            .appendFixedSignedDecimal(DateTimeFieldType.minuteOfHour(), 2).appendLiteral(':')
            .appendFixedSignedDecimal(DateTimeFieldType.secondOfMinute(), 2).toFormatter().withZoneUTC();

    DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder()
            .append(longFormatter.withZone(DateTimeZone.UTC).getPrinter(), new DateTimeParser[] {
                    longFormatter.getParser(), shortFormatter.getParser(), new EpochTimeParser(true) });

    return new FormatDateTimeFormatter("yyyy/MM/dd HH:mm:ss||yyyy/MM/dd||epoch_millis",
            builder.toFormatter().withZone(DateTimeZone.UTC), Locale.ROOT);
}

---

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

License:Apache License

/**
 * Returns a formatter that outputs only those fields specified.
 * <p>/*  w w w  . ja v  a 2  s . c o m*/
 * This method examines the fields provided and returns an ISO-style
 * formatter that best fits. This can be useful for outputting
 * less-common ISO styles, such as YearMonth (YYYY-MM) or MonthDay (--MM-DD).
 * <p>
 * The list provided may have overlapping fields, such as dayOfWeek and
 * dayOfMonth. In this case, the style is chosen based on the following
 * list, thus in the example, the calendar style is chosen as dayOfMonth
 * is higher in priority than dayOfWeek:
 * <ul>
 * <li>monthOfYear - calendar date style
 * <li>dayOfYear - ordinal date style
 * <li>weekOfWeekYear - week date style
 * <li>dayOfMonth - calendar date style
 * <li>dayOfWeek - week date style
 * <li>year
 * <li>weekyear
 * </ul>
 * The supported formats are:
 * <pre>
 * Extended      Basic       Fields
 * 2005-03-25    20050325    year/monthOfYear/dayOfMonth
 * 2005-03       2005-03     year/monthOfYear
 * 2005--25      2005--25    year/dayOfMonth *
 * 2005          2005        year
 * --03-25       --0325      monthOfYear/dayOfMonth
 * --03          --03        monthOfYear
 * ---03         ---03       dayOfMonth
 * 2005-084      2005084     year/dayOfYear
 * -084          -084        dayOfYear
 * 2005-W12-5    2005W125    weekyear/weekOfWeekyear/dayOfWeek
 * 2005-W-5      2005W-5     weekyear/dayOfWeek *
 * 2005-W12      2005W12     weekyear/weekOfWeekyear
 * -W12-5        -W125       weekOfWeekyear/dayOfWeek
 * -W12          -W12        weekOfWeekyear
 * -W-5          -W-5        dayOfWeek
 * 10:20:30.040  102030.040  hour/minute/second/milli
 * 10:20:30      102030      hour/minute/second
 * 10:20         1020        hour/minute
 * 10            10          hour
 * -20:30.040    -2030.040   minute/second/milli
 * -20:30        -2030       minute/second
 * -20           -20         minute
 * --30.040      --30.040    second/milli
 * --30          --30        second
 * ---.040       ---.040     milli *
 * 10-30.040     10-30.040   hour/second/milli *
 * 10:20-.040    1020-.040   hour/minute/milli *
 * 10-30         10-30       hour/second *
 * 10--.040      10--.040    hour/milli *
 * -20-.040      -20-.040    minute/milli *
 *   plus datetime formats like {date}T{time}
 * </pre>
 * * indiates that this is not an official ISO format and can be excluded
 * by passing in <code>strictISO</code> as <code>true</code>.
 * <p>
 * This method can side effect the input collection of fields.
 * If the input collection is modifiable, then each field that was added to
 * the formatter will be removed from the collection, including any duplicates.
 * If the input collection is unmodifiable then no side effect occurs.
 * <p>
 * This side effect processing is useful if you need to know whether all
 * the fields were converted into the formatter or not. To achieve this,
 * pass in a modifiable list, and check that it is empty on exit.
 *
 * @param fields  the fields to get a formatter for, not null,
 *  updated by the method call unless unmodifiable,
 *  removing those fields built in the formatter
 * @param extended  true to use the extended format (with separators)
 * @param strictISO  true to stick exactly to ISO8601, false to include additional formats
 * @return a suitable formatter
 * @throws IllegalArgumentException if there is no format for the fields
 * @since 1.1
 */
public static DateTimeFormatter forFields(Collection<DateTimeFieldType> fields, boolean extended,
        boolean strictISO) {

    if (fields == null || fields.size() == 0) {
        throw new IllegalArgumentException("The fields must not be null or empty");
    }
    Set<DateTimeFieldType> workingFields = new HashSet<>(fields);
    int inputSize = workingFields.size();
    boolean reducedPrec = false;
    DateTimeFormatterBuilder bld = new DateTimeFormatterBuilder();
    // date
    if (workingFields.contains(DateTimeFieldType.monthOfYear())) {
        reducedPrec = dateByMonth(bld, workingFields, extended, strictISO);
    } else if (workingFields.contains(DateTimeFieldType.dayOfYear())) {
        reducedPrec = dateByOrdinal(bld, workingFields, extended);
    } else if (workingFields.contains(DateTimeFieldType.weekOfWeekyear())) {
        reducedPrec = dateByWeek(bld, workingFields, extended, strictISO);
    } else if (workingFields.contains(DateTimeFieldType.dayOfMonth())) {
        reducedPrec = dateByMonth(bld, workingFields, extended, strictISO);
    } else if (workingFields.contains(DateTimeFieldType.dayOfWeek())) {
        reducedPrec = dateByWeek(bld, workingFields, extended, strictISO);
    } else if (workingFields.remove(DateTimeFieldType.year())) {
        bld.append(Constants.ye);
        reducedPrec = true;
    } else if (workingFields.remove(DateTimeFieldType.weekyear())) {
        bld.append(Constants.we);
        reducedPrec = true;
    }
    boolean datePresent = (workingFields.size() < inputSize);

    // time
    time(bld, workingFields, extended, strictISO, reducedPrec, datePresent);

    // result
    if (bld.canBuildFormatter() == false) {
        throw new IllegalArgumentException("No valid format for fields: " + fields);
    }

    // side effect the input collection to indicate the processed fields
    // handling unmodifiable collections with no side effect
    try {
        fields.retainAll(workingFields);
    } catch (UnsupportedOperationException ex) {
        // ignore, so we can handle unmodifiable collections
    }
    return bld.toFormatter();
}

---

From source file:org.dataconservancy.ui.api.FileController.java

License:Apache License

/**
 * Accepts the parameters as specified below and returns the content of the file with matching id and qualifies the
 * criteria specified in the request header.
 * @param idpart id string that uniquely identify requested.
 * @param mimeType specifies the acceptable type of the response's content. The matching file's mime type is
 *        determined using the {@link javax.activation.MimetypesFileTypeMap}'s default map.
 * @param modifiedSince specifies that the request is only for file with matching id that has been modified
 *        since the {@code modifiedSince} date. Files with matching ids that has not been modified since
 *        {@code modifiedSince} date will be disqualified and not returned.
 * @param request http request//from w  ww .j  a v a2 s . c  o  m
 * @throws {@link IOException} when an exception occurs when writing to the {@link HttpServletResponse} object.
 *
 */
@RequestMapping(value = "/{idpart}", method = { RequestMethod.GET })
public void handleFileGetRequest(@PathVariable String idpart,
        @RequestHeader(value = "Accept", required = false) String mimeType,
        @RequestHeader(value = "If-Modified-Since", required = false) @DateTimeFormat(iso = DATE_TIME) Date modifiedSince,
        HttpServletRequest request, HttpServletResponse resp) throws IOException {

    // this impl does not require authz at the moment, but need a user for the fileBizService getFile method
    // ok if null
    Person user = getAuthenticatedUser();

    // Get file id from the request
    String id = requestUtil.buildRequestUrl(request);

    // Resolve the Request URL to the ID of the file (in this case URL == ID)
    if (id == null || id.trim().isEmpty()) {
        resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
        return;
    }

    try {

        archiveService.pollArchive();

        // Get file's last modified date via the fileBizService if it is a DataFile, or
        // via the metadataFileBizService if it is a MetadataFile

        DateTime lastModifiedDate = (fileBizService.getLastModifiedDate(id) != null)
                ? fileBizService.getLastModifiedDate(id)
                : metadataFileBizService.getLastModifiedDate(id);

        // Handle if-modified-since header
        if (failIfModifiedSinceHeader(request, resp, modifiedSince, lastModifiedDate)) {
            return;
        }

        // Get file via fileBizService if it is a DataFile, or
        // via the metadataFileBizService if it is a MetadataFile
        DataFile file = null;
        if (fileBizService.getFile(id, user) != null) {
            file = fileBizService.getFile(id, user);
        } else {
            file = metadataFileBizService.retrieveMetadataFile(id);
        }

        //If file is not found
        if (file == null) {
            resp.sendError(HttpServletResponse.SC_NOT_FOUND, "No file matching this id " + id + " was found.");
        } else { //if file is found

            String fileMimeType = file.getFormat();

            if (fileMimeType == null) {
                fileMimeType = "application/octet-stream";
            }

            //Handling mimeType header
            if (failAcceptHeader(request, resp, mimeType, fileMimeType)) {
                return;
            }

            //Set the Content-Length
            resp.setContentLength((int) file.getSize());
            resp.setStatus(HttpStatus.SC_OK);
            //Calculate ETAG
            resp.setHeader(ETAG, ETagCalculator.calculate(Integer.toString(file.hashCode())));
            DateTimeFormatter fmt = new DateTimeFormatterBuilder().appendPattern("EEE, dd MMM yyyy HH:mm:ss Z")
                    .toFormatter();
            String rfcDate = fmt.print(lastModifiedDate);
            resp.setHeader(LAST_MODIFIED, rfcDate);
            //Set Content-Disposition
            resp.setHeader(CONTENT_DISPOSITION,
                    getResponseContentDispositionString("\"" + file.getName() + "\"", file.getSize()));
            //Set Content-Type
            resp.setContentType(fileMimeType);

            InputStream is = new URL(file.getSource()).openStream();
            IOUtils.copy(is, resp.getOutputStream());
            is.close();
        }
    } catch (BizPolicyException be) {
        handleException(be, request, resp);
    } catch (ArchiveServiceException ae) {
        handleException(ae, request, resp);
    } catch (RelationshipConstraintException re) {
        handleException(re, request, resp);
    }
}

---

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).
 *///  w  w w  .  j a  va 2s .  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 ("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.xpack.sql.parser.ExpressionBuilder.java

License:Open Source License

@Override
public Literal visitTimestampEscapedLiteral(TimestampEscapedLiteralContext ctx) {
    String string = string(ctx.string());

    Location loc = source(ctx);//from  ww w .  j a va  2 s . c  o  m
    // parse yyyy-mm-dd hh:mm:ss(.f...)
    DateTime dt = null;
    try {
        DateTimeFormatter formatter = new DateTimeFormatterBuilder().append(ISODateTimeFormat.date())
                .appendLiteral(" ").append(ISODateTimeFormat.hourMinuteSecondFraction()).toFormatter();
        dt = formatter.parseDateTime(string);
    } catch (IllegalArgumentException ex) {
        throw new ParsingException(loc, "Invalid timestamp received; {}", ex.getMessage());
    }
    return new Literal(loc, dt, DataType.DATE);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• »