/*******************************************************************************
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*******************************************************************************/
package org.apache.ofbiz.base.util;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.TimeZone;
import com.ibm.icu.util.Calendar;
/**
* Utility class for handling java.util.Date, the java.sql data/time classes and related
*/
public final class UtilDateTime {
private static final String[] months = {// // to be translated over CommonMonthName, see example in accounting
"January", "February", "March", "April", "May", "June",
"July", "August", "September", "October", "November",
"December"
};
private static final String[] days = {// to be translated over CommonDayName, see example in accounting
"Monday", "Tuesday", "Wednesday",
"Thursday", "Friday", "Saturday", "Sunday"
};
private static final String[][] timevals = {
{"1000", "millisecond"},
{"60", "second"},
{"60", "minute"},
{"24", "hour"},
{"168", "week"}
};
private static final DecimalFormat df = new DecimalFormat("0.00;-0.00");
/**
* JDBC escape format for java.sql.Date conversions.
*/
private static final String DATE_FORMAT = "yyyy-MM-dd";
/**
* JDBC escape format for java.sql.Timestamp conversions.
*/
private static final String DATE_TIME_FORMAT = "yyyy-MM-dd HH:mm:ss.SSS";
/**
* JDBC escape format for java.sql.Time conversions.
*/
private static final String TIME_FORMAT = "HH:mm:ss";
private UtilDateTime() {}
public static double getInterval(Date from, Date thru) {
return thru != null ? thru.getTime() - from.getTime() : 0;
}
public static int getIntervalInDays(Timestamp from, Timestamp thru) {
return thru != null ? (int) ((thru.getTime() - from.getTime()) / (24*60*60*1000)) : 0;
}
public static Timestamp addDaysToTimestamp(Timestamp start, int days) {
return new Timestamp(start.getTime() + (24L*60L*60L*1000L*days));
}
public static Timestamp addDaysToTimestamp(Timestamp start, Double days) {
return new Timestamp(start.getTime() + ((int) (24L*60L*60L*1000L*days)));
}
public static double getInterval(Timestamp from, Timestamp thru) {
return thru != null ? thru.getTime() - from.getTime() + (thru.getNanos() - from.getNanos()) / 1000000 : 0;
}
public static String formatInterval(Date from, Date thru, int count, Locale locale) {
return formatInterval(getInterval(from, thru), count, locale);
}
public static String formatInterval(Date from, Date thru, Locale locale) {
return formatInterval(from, thru, 2, locale);
}
public static String formatInterval(Timestamp from, Timestamp thru, int count, Locale locale) {
return formatInterval(getInterval(from, thru), count, locale);
}
public static String formatInterval(Timestamp from, Timestamp thru, Locale locale) {
return formatInterval(from, thru, 2, locale);
}
public static String formatInterval(long interval, int count, Locale locale) {
return formatInterval((double) interval, count, locale);
}
public static String formatInterval(long interval, Locale locale) {
return formatInterval(interval, 2, locale);
}
public static String formatInterval(double interval, Locale locale) {
return formatInterval(interval, 2, locale);
}
public static String formatInterval(double interval, int count, Locale locale) {
List<Double> parts = new ArrayList<Double>(timevals.length);
for (String[] timeval: timevals) {
int value = Integer.valueOf(timeval[0]);
double remainder = interval % value;
interval = interval / value;
parts.add(remainder);
}
Map<String, Object> uiDateTimeMap = UtilProperties.getResourceBundleMap("DateTimeLabels", locale);
StringBuilder sb = new StringBuilder();
for (int i = parts.size() - 1; i >= 0 && count > 0; i--) {
Double D = parts.get(i);
double d = D.doubleValue();
if (d < 1) continue;
if (sb.length() > 0) sb.append(", ");
count--;
sb.append(count == 0 ? df.format(d) : Integer.toString(D.intValue()));
sb.append(' ');
Object label;
if (D.intValue() == 1) {
label = uiDateTimeMap.get(timevals[i][1] + ".singular");
} else {
label = uiDateTimeMap.get(timevals[i][1] + ".plural");
}
sb.append(label);
}
return sb.toString();
}
/**
* Return a Timestamp for right now
*
* @return Timestamp for right now
*/
public static java.sql.Timestamp nowTimestamp() {
return getTimestamp(System.currentTimeMillis());
}
/**
* Convert a millisecond value to a Timestamp.
* @param time millsecond value
* @return Timestamp
*/
public static java.sql.Timestamp getTimestamp(long time) {
return new java.sql.Timestamp(time);
}
/**
* Convert a millisecond value to a Timestamp.
* @param milliSecs millsecond value
* @return Timestamp
*/
public static Timestamp getTimestamp(String milliSecs) throws NumberFormatException {
return new Timestamp(Long.parseLong(milliSecs));
}
/**
* Returns currentTimeMillis as String
*
* @return String(currentTimeMillis)
*/
public static String nowAsString() {
return Long.toString(System.currentTimeMillis());
}
/**
* Return a string formatted as yyyyMMddHHmmss
*
* @return String formatted for right now
*/
public static String nowDateString() {
return nowDateString("yyyyMMddHHmmss");
}
/**
* Return a string formatted as format
*
* @return String formatted for right now
*/
public static String nowDateString(String format) {
SimpleDateFormat df = new SimpleDateFormat(format);
return df.format(new Date());
}
/**
* Return a Date for right now
*
* @return Date for right now
*/
public static java.util.Date nowDate() {
return new java.util.Date();
}
public static java.sql.Timestamp getDayStart(java.sql.Timestamp stamp) {
return getDayStart(stamp, 0);
}
public static java.sql.Timestamp getDayStart(java.sql.Timestamp stamp, int daysLater) {
return getDayStart(stamp, daysLater, TimeZone.getDefault(), Locale.getDefault());
}
public static java.sql.Timestamp getNextDayStart(java.sql.Timestamp stamp) {
return getDayStart(stamp, 1);
}
public static java.sql.Timestamp getDayEnd(java.sql.Timestamp stamp) {
return getDayEnd(stamp, Long.valueOf(0));
}
public static java.sql.Timestamp getDayEnd(java.sql.Timestamp stamp, Long daysLater) {
return getDayEnd(stamp, daysLater, TimeZone.getDefault(), Locale.getDefault());
}
/**
* Return the date for the first day of the year
*
* @param stamp
* @return java.sql.Timestamp
*/
public static java.sql.Timestamp getYearStart(java.sql.Timestamp stamp) {
return getYearStart(stamp, 0, 0, 0);
}
public static java.sql.Timestamp getYearStart(java.sql.Timestamp stamp, int daysLater) {
return getYearStart(stamp, daysLater, 0, 0);
}
public static java.sql.Timestamp getYearStart(java.sql.Timestamp stamp, int daysLater, int yearsLater) {
return getYearStart(stamp, daysLater, 0, yearsLater);
}
public static java.sql.Timestamp getYearStart(java.sql.Timestamp stamp, int daysLater, int monthsLater, int yearsLater) {
return getYearStart(stamp, daysLater, monthsLater, yearsLater, TimeZone.getDefault(), Locale.getDefault());
}
public static java.sql.Timestamp getYearStart(java.sql.Timestamp stamp, Number daysLater, Number monthsLater, Number yearsLater) {
return getYearStart(stamp, (daysLater == null ? 0 : daysLater.intValue()),
(monthsLater == null ? 0 : monthsLater.intValue()), (yearsLater == null ? 0 : yearsLater.intValue()));
}
/**
* Return the date for the first day of the month
*
* @param stamp
* @return java.sql.Timestamp
*/
public static java.sql.Timestamp getMonthStart(java.sql.Timestamp stamp) {
return getMonthStart(stamp, 0, 0);
}
public static java.sql.Timestamp getMonthStart(java.sql.Timestamp stamp, int daysLater) {
return getMonthStart(stamp, daysLater, 0);
}
public static java.sql.Timestamp getMonthStart(java.sql.Timestamp stamp, int daysLater, int monthsLater) {
return getMonthStart(stamp, daysLater, monthsLater, TimeZone.getDefault(), Locale.getDefault());
}
/**
* Return the date for the first day of the week
*
* @param stamp
* @return java.sql.Timestamp
*/
public static java.sql.Timestamp getWeekStart(java.sql.Timestamp stamp) {
return getWeekStart(stamp, 0, 0);
}
public static java.sql.Timestamp getWeekStart(java.sql.Timestamp stamp, int daysLater) {
return getWeekStart(stamp, daysLater, 0);
}
public static java.sql.Timestamp getWeekStart(java.sql.Timestamp stamp, int daysLater, int weeksLater) {
return getWeekStart(stamp, daysLater, weeksLater, TimeZone.getDefault(), Locale.getDefault());
}
public static java.sql.Timestamp getWeekEnd(java.sql.Timestamp stamp) {
return getWeekEnd(stamp, TimeZone.getDefault(), Locale.getDefault());
}
public static Calendar toCalendar(java.sql.Timestamp stamp) {
Calendar cal = Calendar.getInstance();
if (stamp != null) {
cal.setTimeInMillis(stamp.getTime());
}
return cal;
}
/**
* Converts a date String into a java.sql.Date
*
* @param date The date String: MM/DD/YYYY
* @return A java.sql.Date made from the date String
*/
public static java.sql.Date toSqlDate(String date) {
java.util.Date newDate = toDate(date, "00:00:00");
if (newDate != null) {
return new java.sql.Date(newDate.getTime());
} else {
return null;
}
}
/**
* Makes a java.sql.Date from separate Strings for month, day, year
*
* @param monthStr The month String
* @param dayStr The day String
* @param yearStr The year String
* @return A java.sql.Date made from separate Strings for month, day, year
*/
public static java.sql.Date toSqlDate(String monthStr, String dayStr, String yearStr) {
java.util.Date newDate = toDate(monthStr, dayStr, yearStr, "0", "0", "0");
if (newDate != null) {
return new java.sql.Date(newDate.getTime());
} else {
return null;
}
}
/**
* Makes a java.sql.Date from separate ints for month, day, year
*
* @param month The month int
* @param day The day int
* @param year The year int
* @return A java.sql.Date made from separate ints for month, day, year
*/
public static java.sql.Date toSqlDate(int month, int day, int year) {
java.util.Date newDate = toDate(month, day, year, 0, 0, 0);
if (newDate != null) {
return new java.sql.Date(newDate.getTime());
} else {
return null;
}
}
/**
* Converts a time String into a java.sql.Time
*
* @param time The time String: either HH:MM or HH:MM:SS
* @return A java.sql.Time made from the time String
*/
public static java.sql.Time toSqlTime(String time) {
java.util.Date newDate = toDate("1/1/1970", time);
if (newDate != null) {
return new java.sql.Time(newDate.getTime());
} else {
return null;
}
}
/**
* Makes a java.sql.Time from separate Strings for hour, minute, and second.
*
* @param hourStr The hour String
* @param minuteStr The minute String
* @param secondStr The second String
* @return A java.sql.Time made from separate Strings for hour, minute, and second.
*/
public static java.sql.Time toSqlTime(String hourStr, String minuteStr, String secondStr) {
java.util.Date newDate = toDate("0", "0", "0", hourStr, minuteStr, secondStr);
if (newDate != null) {
return new java.sql.Time(newDate.getTime());
} else {
return null;
}
}
/**
* Makes a java.sql.Time from separate ints for hour, minute, and second.
*
* @param hour The hour int
* @param minute The minute int
* @param second The second int
* @return A java.sql.Time made from separate ints for hour, minute, and second.
*/
public static java.sql.Time toSqlTime(int hour, int minute, int second) {
java.util.Date newDate = toDate(0, 0, 0, hour, minute, second);
if (newDate != null) {
return new java.sql.Time(newDate.getTime());
} else {
return null;
}
}
/**
* Converts a date and time String into a Timestamp
*
* @param dateTime A combined data and time string in the format "MM/DD/YYYY HH:MM:SS", the seconds are optional
* @return The corresponding Timestamp
*/
public static java.sql.Timestamp toTimestamp(String dateTime) {
java.util.Date newDate = toDate(dateTime);
if (newDate != null) {
return new java.sql.Timestamp(newDate.getTime());
} else {
return null;
}
}
/**
* Converts a date String and a time String into a Timestamp
*
* @param date The date String: MM/DD/YYYY
* @param time The time String: either HH:MM or HH:MM:SS
* @return A Timestamp made from the date and time Strings
*/
public static java.sql.Timestamp toTimestamp(String date, String time) {
java.util.Date newDate = toDate(date, time);
if (newDate != null) {
return new java.sql.Timestamp(newDate.getTime());
} else {
return null;
}
}
/**
* Makes a Timestamp from separate Strings for month, day, year, hour, minute, and second.
*
* @param monthStr The month String
* @param dayStr The day String
* @param yearStr The year String
* @param hourStr The hour String
* @param minuteStr The minute String
* @param secondStr The second String
* @return A Timestamp made from separate Strings for month, day, year, hour, minute, and second.
*/
public static java.sql.Timestamp toTimestamp(String monthStr, String dayStr, String yearStr, String hourStr,
String minuteStr, String secondStr) {
java.util.Date newDate = toDate(monthStr, dayStr, yearStr, hourStr, minuteStr, secondStr);
if (newDate != null) {
return new java.sql.Timestamp(newDate.getTime());
} else {
return null;
}
}
/**
* Makes a Timestamp from separate ints for month, day, year, hour, minute, and second.
*
* @param month The month int
* @param day The day int
* @param year The year int
* @param hour The hour int
* @param minute The minute int
* @param second The second int
* @return A Timestamp made from separate ints for month, day, year, hour, minute, and second.
*/
public static java.sql.Timestamp toTimestamp(int month, int day, int year, int hour, int minute, int second) {
java.util.Date newDate = toDate(month, day, year, hour, minute, second);
if (newDate != null) {
return new java.sql.Timestamp(newDate.getTime());
} else {
return null;
}
}
public static java.sql.Timestamp toTimestamp(Date date) {
if (date == null) return null;
return new Timestamp(date.getTime());
}
/**
* Converts a date and time String into a Date
*
* @param dateTime A combined data and time string in the format "MM/DD/YYYY HH:MM:SS", the seconds are optional
* @return The corresponding Date
*/
public static java.util.Date toDate(String dateTime) {
if (dateTime == null) {
return null;
}
// dateTime must have one space between the date and time...
String date = dateTime.substring(0, dateTime.indexOf(" "));
String time = dateTime.substring(dateTime.indexOf(" ") + 1);
return toDate(date, time);
}
/**
* Converts a date String and a time String into a Date
*
* @param date The date String: MM/DD/YYYY
* @param time The time String: either HH:MM or HH:MM:SS
* @return A Date made from the date and time Strings
*/
public static java.util.Date toDate(String date, String time) {
if (date == null || time == null) return null;
String month;
String day;
String year;
String hour;
String minute;
String second;
int dateSlash1 = date.indexOf("/");
int dateSlash2 = date.lastIndexOf("/");
if (dateSlash1 <= 0 || dateSlash1 == dateSlash2) return null;
int timeColon1 = time.indexOf(":");
int timeColon2 = time.lastIndexOf(":");
if (timeColon1 <= 0) return null;
month = date.substring(0, dateSlash1);
day = date.substring(dateSlash1 + 1, dateSlash2);
year = date.substring(dateSlash2 + 1);
hour = time.substring(0, timeColon1);
if (timeColon1 == timeColon2) {
minute = time.substring(timeColon1 + 1);
second = "0";
} else {
minute = time.substring(timeColon1 + 1, timeColon2);
second = time.substring(timeColon2 + 1);
}
return toDate(month, day, year, hour, minute, second);
}
/**
* Makes a Date from separate Strings for month, day, year, hour, minute, and second.
*
* @param monthStr The month String
* @param dayStr The day String
* @param yearStr The year String
* @param hourStr The hour String
* @param minuteStr The minute String
* @param secondStr The second String
* @return A Date made from separate Strings for month, day, year, hour, minute, and second.
*/
public static java.util.Date toDate(String monthStr, String dayStr, String yearStr, String hourStr,
String minuteStr, String secondStr) {
int month, day, year, hour, minute, second;
try {
month = Integer.parseInt(monthStr);
day = Integer.parseInt(dayStr);
year = Integer.parseInt(yearStr);
hour = Integer.parseInt(hourStr);
minute = Integer.parseInt(minuteStr);
second = Integer.parseInt(secondStr);
} catch (Exception e) {
return null;
}
return toDate(month, day, year, hour, minute, second);
}
/**
* Makes a Date from separate ints for month, day, year, hour, minute, and second.
*
* @param month The month int
* @param day The day int
* @param year The year int
* @param hour The hour int
* @param minute The minute int
* @param second The second int
* @return A Date made from separate ints for month, day, year, hour, minute, and second.
*/
public static java.util.Date toDate(int month, int day, int year, int hour, int minute, int second) {
Calendar calendar = Calendar.getInstance();
try {
calendar.set(year, month - 1, day, hour, minute, second);
calendar.set(Calendar.MILLISECOND, 0);
} catch (Exception e) {
return null;
}
return new java.util.Date(calendar.getTime().getTime());
}
/**
* Makes a date String in the given from a Date
*
* @param date The Date
* @return A date String in the given format
*/
public static String toDateString(java.util.Date date, String format) {
if (date == null) return "";
SimpleDateFormat dateFormat = null;
if (format != null) {
dateFormat = new SimpleDateFormat(format);
} else {
dateFormat = new SimpleDateFormat();
}
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return dateFormat.format(date);
}
/**
* Makes a date String in the format MM/DD/YYYY from a Date
*
* @param date The Date
* @return A date String in the format MM/DD/YYYY
*/
public static String toDateString(java.util.Date date) {
return toDateString(date, "MM/dd/yyyy");
}
/**
* Makes a time String in the format HH:MM:SS from a Date. If the seconds are 0, then the output is in HH:MM.
*
* @param date The Date
* @return A time String in the format HH:MM:SS or HH:MM
*/
public static String toTimeString(java.util.Date date) {
if (date == null) return "";
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);
return (toTimeString(calendar.get(Calendar.HOUR_OF_DAY), calendar.get(Calendar.MINUTE), calendar.get(Calendar.SECOND)));
}
/**
* Makes a time String in the format HH:MM:SS from a separate ints for hour, minute, and second. If the seconds are 0, then the output is in HH:MM.
*
* @param hour The hour int
* @param minute The minute int
* @param second The second int
* @return A time String in the format HH:MM:SS or HH:MM
*/
public static String toTimeString(int hour, int minute, int second) {
String hourStr;
String minuteStr;
String secondStr;
if (hour < 10) {
hourStr = "0" + hour;
} else {
hourStr = "" + hour;
}
if (minute < 10) {
minuteStr = "0" + minute;
} else {
minuteStr = "" + minute;
}
if (second < 10) {
secondStr = "0" + second;
} else {
secondStr = "" + second;
}
if (second == 0) {
return hourStr + ":" + minuteStr;
} else {
return hourStr + ":" + minuteStr + ":" + secondStr;
}
}
/**
* Makes a combined data and time string in the format "MM/DD/YYYY HH:MM:SS" from a Date. If the seconds are 0 they are left off.
*
* @param date The Date
* @return A combined data and time string in the format "MM/DD/YYYY HH:MM:SS" where the seconds are left off if they are 0.
*/
public static String toDateTimeString(java.util.Date date) {
if (date == null) return "";
String dateString = toDateString(date);
String timeString = toTimeString(date);
if (dateString != null && timeString != null) {
return dateString + " " + timeString;
} else {
return "";
}
}
public static String toGmtTimestampString(Timestamp timestamp) {
DateFormat df = DateFormat.getDateTimeInstance();
df.setTimeZone(TimeZone.getTimeZone("GMT"));
return df.format(timestamp);
}
/**
* Makes a Timestamp for the beginning of the month
*
* @return A Timestamp of the beginning of the month
*/
public static java.sql.Timestamp monthBegin() {
Calendar mth = Calendar.getInstance();
mth.set(Calendar.DAY_OF_MONTH, 1);
mth.set(Calendar.HOUR_OF_DAY, 0);
mth.set(Calendar.MINUTE, 0);
mth.set(Calendar.SECOND, 0);
mth.set(Calendar.MILLISECOND, 0);
mth.set(Calendar.AM_PM, Calendar.AM);
return new java.sql.Timestamp(mth.getTime().getTime());
}
/**
* returns a week number in a year for a Timestamp input
*
* @param input Timestamp date
* @return A int containing the week number
*/
public static int weekNumber(Timestamp input) {
return weekNumber(input, TimeZone.getDefault(), Locale.getDefault());
}
/**
* returns a day number in a week for a Timestamp input
*
* @param stamp Timestamp date
* @return A int containing the day number (sunday = 1, saturday = 7)
*/
public static int dayNumber(Timestamp stamp) {
Calendar tempCal = toCalendar(stamp, TimeZone.getDefault(), Locale.getDefault());
return tempCal.get(Calendar.DAY_OF_WEEK);
}
public static int weekNumber(Timestamp input, int startOfWeek) {
Calendar calendar = Calendar.getInstance();
calendar.setFirstDayOfWeek(startOfWeek);
if (startOfWeek == Calendar.MONDAY) {
calendar.setMinimalDaysInFirstWeek(4);
} else if (startOfWeek == Calendar.SUNDAY) {
calendar.setMinimalDaysInFirstWeek(3);
}
calendar.setTime(new java.util.Date(input.getTime()));
return calendar.get(Calendar.WEEK_OF_YEAR);
}
// ----- New methods that take a timezone and locale -- //
public static Calendar getCalendarInstance(TimeZone timeZone, Locale locale) {
return Calendar.getInstance(com.ibm.icu.util.TimeZone.getTimeZone(timeZone.getID()), locale);
}
/**
* Returns a Calendar object initialized to the specified date/time, time zone,
* and locale.
*
* @param date date/time to use
* @param timeZone
* @param locale
* @return Calendar object
* @see java.util.Calendar
*/
public static Calendar toCalendar(Date date, TimeZone timeZone, Locale locale) {
Calendar cal = getCalendarInstance(timeZone, locale);
if (date != null) {
cal.setTime(date);
}
return cal;
}
/**
* Perform date/time arithmetic on a Timestamp. This is the only accurate way to
* perform date/time arithmetic across locales and time zones.
*
* @param stamp date/time to perform arithmetic on
* @param adjType the adjustment type to perform. Use one of the java.util.Calendar fields.
* @param adjQuantity the adjustment quantity.
* @param timeZone
* @param locale
* @return adjusted Timestamp
* @see java.util.Calendar
*/
public static Timestamp adjustTimestamp(Timestamp stamp, int adjType, int adjQuantity, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
tempCal.add(adjType, adjQuantity);
return new Timestamp(tempCal.getTimeInMillis());
}
public static Timestamp adjustTimestamp(Timestamp stamp, Integer adjType, Integer adjQuantity) {
Calendar tempCal = toCalendar(stamp);
tempCal.add(adjType, adjQuantity);
return new Timestamp(tempCal.getTimeInMillis());
}
public static Timestamp getDayStart(Timestamp stamp, TimeZone timeZone, Locale locale) {
return getDayStart(stamp, 0, timeZone, locale);
}
public static Timestamp getDayStart(Timestamp stamp, int daysLater, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
tempCal.set(tempCal.get(Calendar.YEAR), tempCal.get(Calendar.MONTH), tempCal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
tempCal.add(Calendar.DAY_OF_MONTH, daysLater);
Timestamp retStamp = new Timestamp(tempCal.getTimeInMillis());
retStamp.setNanos(0);
return retStamp;
}
public static Timestamp getDayEnd(Timestamp stamp, TimeZone timeZone, Locale locale) {
return getDayEnd(stamp, Long.valueOf(0), timeZone, locale);
}
public static Timestamp getDayEnd(Timestamp stamp, Long daysLater, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
tempCal.set(tempCal.get(Calendar.YEAR), tempCal.get(Calendar.MONTH), tempCal.get(Calendar.DAY_OF_MONTH), 23, 59, 59);
tempCal.add(Calendar.DAY_OF_MONTH, daysLater.intValue());
Timestamp retStamp = new Timestamp(tempCal.getTimeInMillis());
retStamp.setNanos(0);
//MSSQL datetime field has accuracy of 3 milliseconds and setting the nano seconds cause the date to be rounded to next day
return retStamp;
}
public static Timestamp getWeekStart(Timestamp stamp, TimeZone timeZone, Locale locale) {
return getWeekStart(stamp, 0, 0, timeZone, locale);
}
public static Timestamp getWeekStart(Timestamp stamp, int daysLater, TimeZone timeZone, Locale locale) {
return getWeekStart(stamp, daysLater, 0, timeZone, locale);
}
public static Timestamp getWeekStart(Timestamp stamp, int daysLater, int weeksLater, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
tempCal.set(tempCal.get(Calendar.YEAR), tempCal.get(Calendar.MONTH), tempCal.get(Calendar.DAY_OF_MONTH), 0, 0, 0);
tempCal.add(Calendar.DAY_OF_MONTH, daysLater);
tempCal.set(Calendar.DAY_OF_WEEK, tempCal.getFirstDayOfWeek());
tempCal.add(Calendar.WEEK_OF_MONTH, weeksLater);
Timestamp retStamp = new Timestamp(tempCal.getTimeInMillis());
retStamp.setNanos(0);
return retStamp;
}
public static Timestamp getWeekEnd(Timestamp stamp, TimeZone timeZone, Locale locale) {
Timestamp weekStart = getWeekStart(stamp, timeZone, locale);
Calendar tempCal = toCalendar(weekStart, timeZone, locale);
tempCal.add(Calendar.DAY_OF_MONTH, 6);
return getDayEnd(new Timestamp(tempCal.getTimeInMillis()), timeZone, locale);
}
public static Timestamp getMonthStart(Timestamp stamp, TimeZone timeZone, Locale locale) {
return getMonthStart(stamp, 0, 0, timeZone, locale);
}
public static Timestamp getMonthStart(Timestamp stamp, int daysLater, TimeZone timeZone, Locale locale) {
return getMonthStart(stamp, daysLater, 0, timeZone, locale);
}
public static Timestamp getMonthStart(Timestamp stamp, int daysLater, int monthsLater, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
tempCal.set(tempCal.get(Calendar.YEAR), tempCal.get(Calendar.MONTH), 1, 0, 0, 0);
tempCal.add(Calendar.MONTH, monthsLater);
tempCal.add(Calendar.DAY_OF_MONTH, daysLater);
Timestamp retStamp = new Timestamp(tempCal.getTimeInMillis());
retStamp.setNanos(0);
return retStamp;
}
public static Timestamp getMonthEnd(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
tempCal.set(tempCal.get(Calendar.YEAR), tempCal.get(Calendar.MONTH), tempCal.getActualMaximum(Calendar.DAY_OF_MONTH), 0, 0, 0);
return getDayEnd(new Timestamp(tempCal.getTimeInMillis()), timeZone, locale);
}
public static Timestamp getYearStart(Timestamp stamp, TimeZone timeZone, Locale locale) {
return getYearStart(stamp, 0, 0, 0, timeZone, locale);
}
public static Timestamp getYearStart(Timestamp stamp, int daysLater, TimeZone timeZone, Locale locale) {
return getYearStart(stamp, daysLater, 0, 0, timeZone, locale);
}
public static Timestamp getYearStart(Timestamp stamp, int daysLater, int yearsLater, TimeZone timeZone, Locale locale) {
return getYearStart(stamp, daysLater, 0, yearsLater, timeZone, locale);
}
public static Timestamp getYearStart(Timestamp stamp, Number daysLater, Number monthsLater, Number yearsLater, TimeZone timeZone, Locale locale) {
return getYearStart(stamp, (daysLater == null ? 0 : daysLater.intValue()),
(monthsLater == null ? 0 : monthsLater.intValue()), (yearsLater == null ? 0 : yearsLater.intValue()), timeZone, locale);
}
public static Timestamp getYearStart(Timestamp stamp, int daysLater, int monthsLater, int yearsLater, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
tempCal.set(tempCal.get(Calendar.YEAR), Calendar.JANUARY, 1, 0, 0, 0);
tempCal.add(Calendar.YEAR, yearsLater);
tempCal.add(Calendar.MONTH, monthsLater);
tempCal.add(Calendar.DAY_OF_MONTH, daysLater);
Timestamp retStamp = new Timestamp(tempCal.getTimeInMillis());
retStamp.setNanos(0);
return retStamp;
}
public static Timestamp getYearEnd(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
tempCal.set(tempCal.get(Calendar.YEAR), tempCal.getActualMaximum(Calendar.MONTH) + 1, 0, 0, 0, 0);
return getMonthEnd(new Timestamp(tempCal.getTimeInMillis()), timeZone, locale);
}
public static int weekNumber(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar tempCal = toCalendar(stamp, timeZone, locale);
return tempCal.get(Calendar.WEEK_OF_YEAR);
}
/**
* Returns a List of day name Strings - suitable for calendar headings.
* @param locale
* @return List of day name Strings
*/
public static List<String> getDayNames(Locale locale) {
Calendar tempCal = Calendar.getInstance(locale);
tempCal.set(Calendar.DAY_OF_WEEK, tempCal.getFirstDayOfWeek());
SimpleDateFormat dateFormat = new SimpleDateFormat("EEEE", locale);
List<String> resultList = new ArrayList<String>();
for (int i = 0; i < 7; i++) {
resultList.add(dateFormat.format(tempCal.getTime()));
tempCal.roll(Calendar.DAY_OF_WEEK, 1);
}
return resultList;
}
/**
* Returns a List of month name Strings - suitable for calendar headings.
*
* @param locale
* @return List of month name Strings
*/
public static List<String> getMonthNames(Locale locale) {
Calendar tempCal = Calendar.getInstance(locale);
tempCal.set(Calendar.MONTH, Calendar.JANUARY);
SimpleDateFormat dateFormat = new SimpleDateFormat("MMMM", locale);
List<String> resultList = new ArrayList<String>();
for (int i = Calendar.JANUARY; i <= tempCal.getActualMaximum(Calendar.MONTH); i++) {
resultList.add(dateFormat.format(tempCal.getTime()));
tempCal.roll(Calendar.MONTH, 1);
}
return resultList;
}
/**
* Returns an initialized DateFormat object.
*
* @param dateFormat
* optional format string
* @param tz
* @param locale
* can be null if dateFormat is not null
* @return DateFormat object
*/
public static DateFormat toDateFormat(String dateFormat, TimeZone tz, Locale locale) {
DateFormat df = null;
if (UtilValidate.isEmpty(dateFormat)) {
df = DateFormat.getDateInstance(DateFormat.SHORT, locale);
} else {
df = new SimpleDateFormat(dateFormat, locale == null ? Locale.getDefault() : locale);
}
df.setTimeZone(tz);
return df;
}
/**
* Returns an initialized DateFormat object.
* @param dateTimeFormat optional format string
* @param tz
* @param locale can be null if dateTimeFormat is not null
* @return DateFormat object
*/
public static DateFormat toDateTimeFormat(String dateTimeFormat, TimeZone tz, Locale locale) {
DateFormat df = null;
if (UtilValidate.isEmpty(dateTimeFormat)) {
df = DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM, locale);
} else {
df = new SimpleDateFormat(dateTimeFormat, locale == null ? Locale.getDefault() : locale);
}
df.setTimeZone(tz);
return df;
}
/**
* Returns an initialized DateFormat object.
* @param timeFormat optional format string
* @param tz
* @param locale can be null if timeFormat is not null
* @return DateFormat object
*/
public static DateFormat toTimeFormat(String timeFormat, TimeZone tz, Locale locale) {
DateFormat df = null;
if (UtilValidate.isEmpty(timeFormat)) {
df = DateFormat.getTimeInstance(DateFormat.MEDIUM, locale);
} else {
df = new SimpleDateFormat(timeFormat, locale == null ? Locale.getDefault() : locale);
}
df.setTimeZone(tz);
return df;
}
/**
* Localized String to Timestamp conversion. To be used in tandem with timeStampToString().
*/
public static Timestamp stringToTimeStamp(String dateTimeString, TimeZone tz, Locale locale) throws ParseException {
return stringToTimeStamp(dateTimeString, null, tz, locale);
}
/**
* Localized String to Timestamp conversion. To be used in tandem with timeStampToString().
*/
public static Timestamp stringToTimeStamp(String dateTimeString, String dateTimeFormat, TimeZone tz, Locale locale) throws ParseException {
DateFormat dateFormat = toDateTimeFormat(dateTimeFormat, tz, locale);
Date parsedDate = dateFormat.parse(dateTimeString);
return new Timestamp(parsedDate.getTime());
}
/**
* Localized Timestamp to String conversion. To be used in tandem with stringToTimeStamp().
*/
public static String timeStampToString(Timestamp stamp, TimeZone tz, Locale locale) {
return timeStampToString(stamp, null, tz, locale);
}
/**
* Localized Timestamp to String conversion. To be used in tandem with stringToTimeStamp().
*/
public static String timeStampToString(Timestamp stamp, String dateTimeFormat, TimeZone tz, Locale locale) {
DateFormat dateFormat = toDateTimeFormat(dateTimeFormat, tz, locale);
return dateFormat.format(stamp);
}
// Private lazy-initializer class
private static class TimeZoneHolder {
private static final List<TimeZone> availableTimeZoneList = getTimeZones();
private static List<TimeZone> getTimeZones() {
ArrayList<TimeZone> availableTimeZoneList = new ArrayList<TimeZone>();
List<String> idList = null;
String tzString = UtilProperties.getPropertyValue("general", "timeZones.available");
if (UtilValidate.isNotEmpty(tzString)) {
idList = StringUtil.split(tzString, ",");
} else {
idList = Arrays.asList(TimeZone.getAvailableIDs());
}
for (String id : idList) {
TimeZone curTz = TimeZone.getTimeZone(id);
availableTimeZoneList.add(curTz);
}
availableTimeZoneList.trimToSize();
return Collections.unmodifiableList(availableTimeZoneList);
}
}
/** Returns a List of available TimeZone objects.
* @see java.util.TimeZone
*/
public static List<TimeZone> availableTimeZones() {
return TimeZoneHolder.availableTimeZoneList;
}
/** Returns a TimeZone object based upon a time zone ID. Method defaults to
* server's time zone if tzID is null or empty.
* @see java.util.TimeZone
*/
public static TimeZone toTimeZone(String tzId) {
if (UtilValidate.isEmpty(tzId)) {
return TimeZone.getDefault();
} else {
return TimeZone.getTimeZone(tzId);
}
}
/** Returns a TimeZone object based upon an hour offset from GMT.
* @see java.util.TimeZone
*/
public static TimeZone toTimeZone(int gmtOffset) {
if (gmtOffset > 12 || gmtOffset < -14) {
throw new IllegalArgumentException("Invalid GMT offset");
}
String tzId = gmtOffset > 0 ? "Etc/GMT+" : "Etc/GMT";
return TimeZone.getTimeZone(tzId + gmtOffset);
}
public static int getSecond(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.SECOND);
}
public static int getMinute(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.MINUTE);
}
public static int getHour(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.HOUR_OF_DAY);
}
public static int getDayOfWeek(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.DAY_OF_WEEK);
}
public static int getDayOfMonth(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.DAY_OF_MONTH);
}
public static int getDayOfYear(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.DAY_OF_YEAR);
}
public static int getWeek(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.WEEK_OF_YEAR);
}
public static int getMonth(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.MONTH);
}
public static int getYear(Timestamp stamp, TimeZone timeZone, Locale locale) {
Calendar cal = toCalendar(stamp, timeZone, locale);
return cal.get(Calendar.YEAR);
}
public static Date getEarliestDate() {
Calendar cal = getCalendarInstance(TimeZone.getTimeZone("GMT"), Locale.getDefault());
cal.set(Calendar.YEAR, cal.getActualMinimum(Calendar.YEAR));
cal.set(Calendar.MONTH, cal.getActualMinimum(Calendar.MONTH));
cal.set(Calendar.DAY_OF_MONTH, 1);
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();
}
public static Date getLatestDate() {
Calendar cal = getCalendarInstance(TimeZone.getTimeZone("GMT"), Locale.getDefault());
cal.set(Calendar.YEAR, cal.getActualMaximum(Calendar.YEAR));
cal.set(Calendar.MONTH, cal.getActualMaximum(Calendar.MONTH));
cal.set(Calendar.DAY_OF_MONTH, cal.getActualMaximum(Calendar.DAY_OF_MONTH));
cal.set(Calendar.HOUR_OF_DAY, 23);
cal.set(Calendar.MINUTE, 59);
cal.set(Calendar.SECOND, 59);
cal.set(Calendar.MILLISECOND, 999);
return cal.getTime();
}
/**
* Returns a copy of <code>date</code> that cannot be modified.
* Attempts to modify the returned date will result in an
* <tt>UnsupportedOperationException</tt>.
*
* @param date
*/
public static Date unmodifiableDate(Date date) {
if (date instanceof ImmutableDate) {
return date;
}
return new ImmutableDate(date.getTime());
}
@SuppressWarnings("serial")
private static class ImmutableDate extends Date {
private ImmutableDate(long date) {
super(date);
}
@Override
public Object clone() {
// No need to clone an immutable object.
return this;
}
@Deprecated
public void setYear(int year) {
throw new UnsupportedOperationException();
}
@Deprecated
public void setMonth(int month) {
throw new UnsupportedOperationException();
}
@Deprecated
public void setDate(int date) {
throw new UnsupportedOperationException();
}
@Deprecated
public void setHours(int hours) {
throw new UnsupportedOperationException();
}
@Deprecated
public void setMinutes(int minutes) {
throw new UnsupportedOperationException();
}
@Deprecated
public void setSeconds(int seconds) {
throw new UnsupportedOperationException();
}
@Override
public void setTime(long time) {
throw new UnsupportedOperationException();
}
}
public static String getDateFormat() {
return DATE_FORMAT;
}
public static String getDateTimeFormat() {
return DATE_TIME_FORMAT;
}
public static String getTimeFormat() {
return TIME_FORMAT;
}
}