Java tutorial
/** * Copyright (c) 2003 - 2007 OpenSubsystems s.r.o. Slovak Republic. All rights reserved. * * Project: OpenSubsystems * * $Id: DateUtils.java,v 1.7 2007/01/07 06:14:00 bastafidli Exp $ * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; version 2 of the License. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ import java.sql.Timestamp; import java.text.DateFormat; import java.text.ParseException; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date; import java.util.GregorianCalendar; /** * Collection of useful utilities to work with dates. * * @version $Id: DateUtils.java,v 1.7 2007/01/07 06:14:00 bastafidli Exp $ * @author Miro Halas * @code.reviewer Miro Halas * @code.reviewed 1.5 2005/09/13 13:23:15 bastafidli */ public final class DateUtils { // Constants //////////////////////////////////////////////////////////////// /** * One second in milliseconds. */ public static final long ONE_SECOND = 1000L; /** * One minute in milliseconds. */ public static final long ONE_MINUTE = ONE_SECOND * 60L; /** * One hour in milliseconds. */ public static final long ONE_HOUR = ONE_MINUTE * 60L; /** * One day in milliseconds. */ public static final long ONE_DAY = ONE_HOUR * 24L; /** * Separator we used to separate time from the nanosecond portion of the * timestamp when converted to string. */ public static final char NANO_SEPARATOR = ':'; /** * Constant for timing type */ public static final int TIMING_NEVER = 0; /** * Constant for timing type */ public static final int TIMING_MINUTES = 1; /** * Constant for timing type */ public static final int TIMING_HOURS = 2; /** * Constant for timing type */ public static final int TIMING_DAYS = 3; /** * Constant for timing type */ public static final int TIMING_WEEKS = 4; /** * Constant for timing type */ public static final int TIMING_MONTHS = 5; /** * Constant for timing type */ public static final int TIMING_YEARS = 6; /** * Constant for timing type */ public static final int TIMING_NONE = 7; /** * Constant for current date code used in date/time formulas */ public static final String CURRENT_DATE_CODE = "now"; /** * Constant for dynamic date code used in date/time formulas */ public static final char YEAR_CODE = 'y'; /** * Constant for dynamic date code used in date/time formulas */ public static final char MONTH_CODE = 'M'; /** * Constant for dynamic date code used in date/time formulas */ public static final char WEEK_CODE = 'w'; /** * Constant for dynamic date code used in date/time formulas */ public static final char DAY_CODE = 'd'; /** * Constant for dynamic date code used in date/time formulas */ public static final char HOUR_CODE = 'h'; /** * Constant for dynamic date code used in date/time formulas */ public static final char MINUTE_CODE = 'm'; /** * Constant for dynamic date code used in date/time formulas */ public static final char SECOND_CODE = 's'; /** * constant for date type DATE */ public static final int DATE_TYPE_DATE = 1; /** * constant for date type TIME */ public static final int DATE_TYPE_TIME = 2; /** * constant for date type DATETIME */ public static final int DATE_TYPE_DATETIME = 3; // Constants for period start types ///////////////////////////////////////// // TODO: For Miro: Remove this code once all the code which referred to these // constants was fixed // /** // * constant for period type // */ // public static final int PERIOD_START_TYPE_NONE = 0; // // /** // * constant for period type // */ // public static final int PERIOD_START_TYPE_CREATION = 1; // // /** // * constant for period type // */ // public static final int PERIOD_START_TYPE_COMPLETION = 2; // // /** // * constant for period type // */ // public static final int PERIOD_START_TYPE_APPROVAL = 3; // // /** // * constant for period type // */ // public static final int PERIOD_START_TYPE_ACTIVATION = 4; // // /** // * constant for period type // */ // public static final int PERIOD_START_TYPE_INACTIVATION = 5; // // /** // * constant for period type // */ // public static final int PERIOD_START_TYPE_DYNAMIC = 6; // // /** // * constant for period type code // */ // public static final int PERIOD_TYPE_CODE = 99; // // /** // * constant for period type object // */ // public static final Integer PERIOD_TYPE_OBJ = new Integer(PERIOD_TYPE_CODE); // Cached variables ///////////////////////////////////////////////////////// /** * static SimpleDateFormat for date format to display on UI and in messages. */ public static final SimpleDateFormat DATE_FORMAT = (SimpleDateFormat) DateFormat .getDateInstance(DateFormat.SHORT); /** * static SimpleDateFormat for time format to display on UI and in messages. */ public static final SimpleDateFormat TIME_FORMAT = (SimpleDateFormat) DateFormat .getTimeInstance(DateFormat.MEDIUM); /** * static SimpleDateFormat for datetime format to display on UI and in messages. */ public static final SimpleDateFormat DATETIME_FORMAT = (SimpleDateFormat) DateFormat .getDateTimeInstance(DateFormat.SHORT, DateFormat.MEDIUM); /** * static SimpleDateFormat for date format to store date as string so that * it is stored consistently. */ public static final SimpleDateFormat DATE_STORE_FORMAT = new SimpleDateFormat("MM/dd/yyyy"); /** * static SimpleDateFormat for time format to store time as string so that * it is stored consistently. */ public static final SimpleDateFormat TIME_STORE_FORMAT = new SimpleDateFormat("HH:mm:ss"); /** * static SimpleDateFormat for datetime format to store date and time as * string so that it is stored consistently. */ public static final SimpleDateFormat DATETIME_STORE_FORMAT = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss"); /** * static SimpleDateFormat for date format for sql date */ public static final SimpleDateFormat DATE_SQL_FORMAT = new SimpleDateFormat("yyyy-MM-dd 00:00:00"); /** * static SimpleDateFormat for time format for sql time */ public static final SimpleDateFormat TIME_SQL_FORMAT = new SimpleDateFormat("1970-01-01 HH:mm:ss"); /** * static SimpleDateFormat for datetime format for sql date and time */ public static final SimpleDateFormat DATETIME_SQL_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); // Constructors ///////////////////////////////////////////////////////////// /** * Private constructor since this class cannot be instantiated */ private DateUtils() { // Do nothing } // Public methods /////////////////////////////////////////////////////////// /** * Check if two dates equals regardless of the time. Two null dates are equal. * Null and not null dates are not equal. * * @param dtFirst - first date to compare, can be null * @param dtSecond - second date to compare, can be null * @return boolean - true if two dates equals regardless of what the time is */ public static boolean dateEquals(Date dtFirst, Date dtSecond) { boolean bReturn = false; // If they are the same object, they are equals bReturn = (dtFirst == dtSecond); if (!bReturn) { if (dtFirst == null) { // Two null dates are the same bReturn = (dtSecond == null); } else { if (dtSecond != null) { Calendar compCalendar; int iEra; int iYear; int iMonth; int iDay; compCalendar = Calendar.getInstance(); compCalendar.setTime(dtFirst); iEra = compCalendar.get(Calendar.ERA); iYear = compCalendar.get(Calendar.YEAR); iMonth = compCalendar.get(Calendar.MONTH); iDay = compCalendar.get(Calendar.DATE); compCalendar.setTime(dtSecond); bReturn = ((iEra == compCalendar.get(Calendar.ERA)) && (iYear == compCalendar.get(Calendar.YEAR)) && (iMonth == compCalendar.get(Calendar.MONTH)) && (iDay == compCalendar.get(Calendar.DATE))); } } } return bReturn; } /** * Check if two times equals regardless of the date. Two null times are equal. * Null and not null times are not equal. * * @param dtFirst - first time to compare, can be null * @param dtSecond - second time to compare, can be null * @param bIgnoreMilliseconds - if true milliseconds will be ignored in comparison * @return boolean - true if two time equals regardless of what the date is */ public static boolean timeEquals(Date dtFirst, Date dtSecond, boolean bIgnoreMilliseconds) { boolean bReturn = false; // If they are the same object, they are equals bReturn = (dtFirst == dtSecond); if (!bReturn) { if (dtFirst == null) { // Two null dates are the same bReturn = (dtSecond == null); } else { if (dtSecond != null) { Calendar compCalendar; int iHour; int iMinute; int iSecond; int iMili; compCalendar = Calendar.getInstance(); compCalendar.setTime(dtFirst); iHour = compCalendar.get(Calendar.HOUR_OF_DAY); iMinute = compCalendar.get(Calendar.MINUTE); iSecond = compCalendar.get(Calendar.SECOND); iMili = compCalendar.get(Calendar.MILLISECOND); compCalendar.setTime(dtSecond); bReturn = ((iHour == compCalendar.get(Calendar.HOUR_OF_DAY)) && (iMinute == compCalendar.get(Calendar.MINUTE)) && (iSecond == compCalendar.get(Calendar.SECOND)) && ((bIgnoreMilliseconds) || (iMili == compCalendar.get(Calendar.MILLISECOND)))); } } } return bReturn; } /** * Check if two dates and times are equal. Two null dates are equal. Null * and not null dates are not equal. * * @param dtFirst - first date time to compare, can be null * @param dtSecond - second date time to compare, can be null * @return boolean - true if two date and times are equal */ public static boolean dateAndTimeEquals(Date dtFirst, Date dtSecond) { boolean bReturn = false; // If they are the same object, they are equals bReturn = (dtFirst == dtSecond); if (!bReturn) { if (dtFirst == null) { // Two null dates are the same bReturn = (dtSecond == null); } else { if (dtSecond != null) { // They are both not null so they have to match to millisecond // (actually to nanosecond since the getTime takes nanoseconds // into account) bReturn = (dtFirst.getTime() == dtSecond.getTime()); } } } return bReturn; } /** * Check if String representing date is function or date. Date is a function * (formula) if it starts with the current date/time variable which can be * followed by expression describing period from current date. * * @param strValue - string representation of date or date function * @return boolean - date function flag */ public static boolean isFunction(String strValue) { boolean bReturn = false; if ((strValue != null) && (strValue.length() > 0) && (strValue.trim().startsWith(CURRENT_DATE_CODE))) { bReturn = true; } return bReturn; } /** * Parse date time value from given string resolving any functions or formulas * the string can contain. This method can be therefore used if the passed * string contains string representation date, time or timestamp or a formula * such as now + 3h - 1m + 4d. * * @param strValue - string representation of date or date function * @param iDateType - date type code, one of the DATE_TYPE_XXX constants * @param stored - flag if Date should be parsed using format used for * storage or for display * @return Timestamp - parsed date or null if date was null * @throws OSSInvalidDataException - error during parsing */ public static Timestamp parseDateTime(String strValue, int iDateType, boolean stored) { Timestamp tsReturn = null; Calendar workCal = GregorianCalendar.getInstance(); if (strValue != null && strValue.length() > 0) { strValue = strValue.trim(); if (strValue.startsWith(CURRENT_DATE_CODE)) { strValue = strValue.replaceAll("[ ]", ""); // If the user specified "UseCurrent", then substitute the // current date/time in the value workCal.setTime(new Date()); // Log.getInstance().debug("Parsing current date " + strValue); // Parse the date math int iBeginIndex = CURRENT_DATE_CODE.length(); int iMaxLength = strValue.length(); int iSign = 1; int iNumberIndex; int iValue; char cChar = ' '; while (iBeginIndex < iMaxLength) { // This has to be sign if (strValue.charAt(iBeginIndex) == '+') { iSign = 1; } else if (strValue.charAt(iBeginIndex) == '-') { iSign = -1; } else { // Incorrect String throw new RuntimeException("Date function is in incorrect format: " + strValue + " at " + strValue.substring(iBeginIndex)); } iBeginIndex++; // Now we have to have number iNumberIndex = iBeginIndex; while (((iBeginIndex == iNumberIndex) || Character.isDigit(cChar)) && (iBeginIndex < iMaxLength)) { cChar = strValue.charAt(iBeginIndex++); } // We have to go one back because we should stop on modifier (e.g 1m) iBeginIndex--; try { iValue = Integer.parseInt(strValue.substring(iNumberIndex, iBeginIndex)); } catch (NumberFormatException nmeExc) { // Incorrect String throw new RuntimeException("Date function is in incorrect format: " + strValue + " at " + strValue.substring(iNumberIndex)); } // This has to be modifier: y - year, M - month, w - week, // d - day, h - hour, m - minute, s - second cChar = strValue.charAt(iBeginIndex); switch (cChar) { case (YEAR_CODE): { if (iDateType == DATE_TYPE_TIME) { throw new RuntimeException( "Date function is in incorrect format: " + "used YEAR modifier for TIME type"); } workCal.add(Calendar.YEAR, iSign * iValue); break; } case (MONTH_CODE): { if (iDateType == DATE_TYPE_TIME) { throw new RuntimeException( "Date function is in incorrect format: " + "used MONTH modifier for TIME type"); } workCal.add(Calendar.MONTH, iSign * iValue); break; } case (WEEK_CODE): { if (iDateType == DATE_TYPE_TIME) { throw new RuntimeException( "Date function is in incorrect format: " + "used WEEK modifier for TIME type"); } workCal.add(Calendar.WEEK_OF_YEAR, iSign * iValue); break; } case (DAY_CODE): { if (iDateType == DATE_TYPE_TIME) { throw new RuntimeException( "Date function is in incorrect format: " + "used DAY modifier for TIME type"); } workCal.add(Calendar.DATE, iSign * iValue); break; } case (HOUR_CODE): { if (iDateType == DATE_TYPE_DATE) { throw new RuntimeException( "Date function is in incorrect format: " + "used HOUR modifier for DATE type"); } workCal.add(Calendar.HOUR, iSign * iValue); break; } case (MINUTE_CODE): { if (iDateType == DATE_TYPE_DATE) { throw new RuntimeException("Date function is in incorrect format: " + "used MINUTE modifier for DATE type"); } workCal.add(Calendar.MINUTE, iSign * iValue); break; } case (SECOND_CODE): { if (iDateType == DATE_TYPE_DATE) { throw new RuntimeException("Date function is in incorrect format: " + "used SECOND modifier for DATE type"); } workCal.add(Calendar.SECOND, iSign * iValue); break; } default: { // Incorrect String throw new RuntimeException("Date function is in incorrect format: " + strValue + " at " + strValue.substring(iBeginIndex)); } } iBeginIndex++; } tsReturn = new Timestamp(workCal.getTimeInMillis()); } else { try { if (stored) { switch (iDateType) { case (DATE_TYPE_DATE): { tsReturn = new Timestamp(DATE_STORE_FORMAT.parse(strValue).getTime()); break; } case (DATE_TYPE_TIME): { tsReturn = new Timestamp(TIME_STORE_FORMAT.parse(strValue).getTime()); break; } case (DATE_TYPE_DATETIME): { tsReturn = new Timestamp(DATETIME_STORE_FORMAT.parse(strValue).getTime()); break; } default: { assert false : "Unknown date type " + iDateType; } } } else { switch (iDateType) { case (DATE_TYPE_DATE): { tsReturn = new Timestamp(DATE_FORMAT.parse(strValue).getTime()); break; } case (DATE_TYPE_TIME): { tsReturn = new Timestamp(TIME_FORMAT.parse(strValue).getTime()); break; } case (DATE_TYPE_DATETIME): { tsReturn = new Timestamp(DATETIME_FORMAT.parse(strValue).getTime()); break; } default: { assert false : "Unknown date type " + iDateType; } } } } catch (ParseException peExc) { throw new RuntimeException("Date is in incorrect format. Problems with parsing.", peExc); } } } return tsReturn; } /** * Parse the specified period into string displaying number of days the * period represents. * * @param lPeriod - period in miliseconds * @return String - period in format 'x day(s)' or '' if not valid period */ public static String parseDayPeriod(long lPeriod) { StringBuffer sbReturn = new StringBuffer(); long lDays = 0L; if (lPeriod > 0) { // we will count each started day as counted day lPeriod = lPeriod + DateUtils.ONE_DAY - 1; lDays = lPeriod / DateUtils.ONE_DAY; sbReturn.append(lDays); if (lDays == 1L) { sbReturn.append(" day"); } else { sbReturn.append(" days"); } } else { sbReturn.append("0 days"); } return sbReturn.toString(); } /** * Parse the specified period into string displaying date and time the * period represents. * * @param lPeriod - preiod in miliseconds * @return String - period in format 'x day(s) y hour(s) z minute(s)' * or '' if not valid period */ public static String parseDayTimePeriod(long lPeriod) { StringBuffer sbReturn = new StringBuffer(); long lHelp = 0L; if (lPeriod > 0) { lPeriod = lPeriod + DateUtils.ONE_MINUTE - 1; // we will count each started day as counted day lHelp = lPeriod / DateUtils.ONE_DAY; if (lHelp > 0) { sbReturn.append(lHelp); if (lHelp == 1L) { sbReturn.append(" d "); } else { sbReturn.append(" d "); } } lPeriod = lPeriod % DateUtils.ONE_DAY; lHelp = lPeriod / DateUtils.ONE_HOUR; if (lHelp > 0 || sbReturn.length() > 0) { sbReturn.append(lHelp); if (lHelp == 1L) { sbReturn.append(" h "); } else { sbReturn.append(" h "); } } lPeriod = lPeriod % DateUtils.ONE_HOUR; lHelp = lPeriod / DateUtils.ONE_MINUTE; if (lHelp > 0 || sbReturn.length() > 0) { sbReturn.append(lHelp); if (lHelp == 1L) { sbReturn.append(" min"); } else { sbReturn.append(" min"); } } } else { sbReturn.append("0 min"); } return sbReturn.toString(); } // TODO: For Miro: Remove this code once all the code which referred to these // was fixed. These should be moved to a GUI related class. // /** // * Method for list of timing types. // * // * @return List - list of timing types // */ // public static List getTimingTypes( // ) // { // List lstTimingTypes = new ArrayList(); // // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_MINUTES), // "Minute(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_HOURS), "Hour(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_DAYS), "Day(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_WEEKS), "Week(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_MONTHS), "Month(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_YEARS), "Year(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_NEVER), "Never")); // // return lstTimingTypes; // } // /** // * Method for list of timing types with None option. // * // * @return List - list of timing types // */ // public static List getTimingTypesWithNone( // ) // { // List lstTimingTypes = new ArrayList(); // // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_NONE), "None")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_MINUTES), // "Minute(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_HOURS), "Hour(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_DAYS), "Day(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_WEEKS), "Week(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_MONTHS), "Month(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_YEARS), "Year(s)")); // lstTimingTypes.add(new SelectOption(Integer.toString(DateUtils.TIMING_NEVER), "Never")); // // return lstTimingTypes; // } // /** // * Method for getting string name of the timing type. // * // * @param iTimingType - timing type constant // * @return String - string name of timing type // */ // public static String getTimingTypeName( // int iTimingType // ) // { // String outTimingTypeName = "Never"; // switch (iTimingType) // { // case (DateUtils.TIMING_NEVER): // { // outTimingTypeName = "Never"; // break; // } // case (DateUtils.TIMING_MINUTES): // { // outTimingTypeName = "Minute(s)"; // break; // } // case (DateUtils.TIMING_HOURS): // { // outTimingTypeName = "Hour(s)"; // break; // } // case (DateUtils.TIMING_DAYS): // { // outTimingTypeName = "Day(s)"; // break; // } // case (DateUtils.TIMING_WEEKS): // { // outTimingTypeName = "Week(s)"; // break; // } // case (DateUtils.TIMING_MONTHS): // { // outTimingTypeName = "Month(s)"; // break; // } // case (DateUtils.TIMING_YEARS): // { // outTimingTypeName = "Year(s)"; // break; // } // case (DateUtils.TIMING_NONE): // { // outTimingTypeName = "None"; // break; // } // } // // return outTimingTypeName; // } /** * Get expiration timestamp from start date, period type and duration. For * example if the start date is now, period type is hour and duration is 2 * then the result will be timestamp representing now + 2 hours. * * @param tsStartDate - start date of period counting * @param iPeriodType - one of the period type constant TIMING_XXX * @param iPeriodDuration - period duration, number of time units specified * by period type * @return Timestamp - date of period expiration or null if any problem */ public static Timestamp getPeriodExpiration(Timestamp tsStartDate, int iPeriodType, int iPeriodDuration) { Timestamp tsReturn = null; Calendar calHelp; if (tsStartDate != null && iPeriodDuration > 0 && iPeriodType > TIMING_NEVER && iPeriodType < TIMING_NONE) { calHelp = Calendar.getInstance(); calHelp.setTime(tsStartDate); switch (iPeriodType) { case (TIMING_MINUTES): { calHelp.add(Calendar.MINUTE, iPeriodDuration); break; } case (TIMING_HOURS): { calHelp.add(Calendar.HOUR, iPeriodDuration); break; } case (TIMING_DAYS): { calHelp.add(Calendar.DATE, iPeriodDuration); break; } case (TIMING_WEEKS): { calHelp.add(Calendar.WEEK_OF_YEAR, iPeriodDuration); break; } case (TIMING_MONTHS): { calHelp.add(Calendar.MONTH, iPeriodDuration); break; } case (TIMING_YEARS): { calHelp.add(Calendar.YEAR, iPeriodDuration); break; } default: { assert false : "Not supported Timing type " + iPeriodType; } } tsReturn = new Timestamp(calHelp.getTimeInMillis()); } return tsReturn; } /** * Method to compare time periods * * @param iPeriodType1 - first period type, one of the period type constant * TIMING_XXX * @param iPeriodDuration1 - first period duration * @param iPeriodType2 - second period type, one of the period type constant * TIMING_XXX * @param iPeriodDuration2 - second period duration * @return int - 1 - first period is longer * 0 - periods are same * -1 - first period is shorter */ public static int comparePeriods(int iPeriodType1, int iPeriodDuration1, int iPeriodType2, int iPeriodDuration2) { int iReturn = 0; if ((iPeriodType1 != TIMING_NEVER) && (iPeriodType1 != TIMING_NONE) && (iPeriodType2 != TIMING_NEVER) && (iPeriodType2 != TIMING_NONE)) { Timestamp tsTimestamp1 = getPeriodExpiration(new Timestamp(0), iPeriodType1, iPeriodDuration1); Timestamp tsTimestamp2 = getPeriodExpiration(new Timestamp(0), iPeriodType2, iPeriodDuration2); // TODO: Improve: When would any of these be null? if ((tsTimestamp1 != null) && (tsTimestamp2 != null)) { if (tsTimestamp1.after(tsTimestamp2)) { iReturn = 1; } else if (tsTimestamp2.after(tsTimestamp1)) { iReturn = -1; } } } else { if (iPeriodType1 != iPeriodType2) { if (iPeriodType1 == TIMING_NEVER) { iReturn = 1; } else if (iPeriodType1 == TIMING_NONE) { iReturn = -1; } else if (iPeriodType2 == TIMING_NEVER) { iReturn = -1; } else if (iPeriodType2 == TIMING_NONE) { iReturn = 1; } } } return iReturn; } /** * Convert timestamp to string including it's nanosecond portion so that it * can be safely stored in variable of web page. * * @param tsTimestamp - timestamp to convert * @return String - text containing time and nanosecond portion of timestamp */ public static String getTimestampAsString(Timestamp tsTimestamp) { StringBuffer sbTimestamp = new StringBuffer(); sbTimestamp.append(tsTimestamp.getTime()); sbTimestamp.append(NANO_SEPARATOR); sbTimestamp.append(tsTimestamp.getNanos()); return sbTimestamp.toString(); } /** * Function returns time string in the form MM:SS.MS from the input specified in miliseconds. * * @param lTimeInMiliseconds - time in miliseconds * @return String - string representation of miliseconds in the form MM:SS.MS */ public static String getStringTime(long lTimeInMiliseconds) { long lTotalMS = lTimeInMiliseconds; long lMS = lTotalMS % 1000; long lTotalSecs = lTotalMS / 1000; long lSecs = lTotalSecs % 60; long lTotalMins = lTotalSecs / 60; long lMinutes = lTotalMins % 60; long lHours = lTotalMins / 60; StringBuffer sbBuffer = new StringBuffer(); if (lHours > 0) { sbBuffer.append(lHours); sbBuffer.append(":"); sbBuffer.append(lMinutes); sbBuffer.append(":"); sbBuffer.append(lSecs); sbBuffer.append("."); sbBuffer.append(lMS); } else if (lMinutes > 0) { sbBuffer.append(lMinutes); sbBuffer.append(":"); sbBuffer.append(lSecs); sbBuffer.append("."); sbBuffer.append(lMS); } else if (lSecs > 0) { sbBuffer.append(lSecs); sbBuffer.append("."); sbBuffer.append(lMS); sbBuffer.append(" seconds"); } else { sbBuffer.append(lMS); sbBuffer.append(" ms"); } return sbBuffer.toString(); } // TODO: For Miro: Remove this code once all the code which referred to these // was fixed. These should be moved to a GUI or business logic related class. // /** // * Method to check if valid period settings // * // * @param iPeriod - period length // * @param iPeriodType - period type // * @param iPeriodStartType - period start type // * @param iAttributeId - attribute ID for dynamic period start type // * @param bPeriodException - period exception flag // * @param strPeriodName - period name used for exception message // * @param bAdvancePeriodType - flag if advanced period type (includes also start type) // * @param bfideException - invalid data exception // */ // public static void validatePeriod( // int iPeriod, // int iPeriodType, // int iPeriodStartType, // int iAttributeId, // boolean bPeriodException, // String strPeriodName, // boolean bAdvancePeriodType, // OSSInvalidDataException messageException // ) // { // if ((iPeriod > 0) // || ((iPeriodType != TIMING_NONE) && (iPeriodType != TIMING_NEVER)) // || (bPeriodException) || (iPeriodStartType != PERIOD_START_TYPE_NONE)) // { // if (iPeriod <= 0) // { // if (messageException == null) // { // messageException = new OSSInvalidDataException(); // } // messageException.getErrorMessages().addMessage( // PERIOD_TYPE_OBJ, // "You have to set valid period length for " + strPeriodName + " type." // ); // } // else if ((iPeriodType == TIMING_NONE) || (iPeriodType == TIMING_NEVER)) // { // if (messageException == null) // { // messageException = new OSSInvalidDataException(); // } // messageException.getErrorMessages().addMessage( // PERIOD_TYPE_OBJ, // "You have to set valid period type for " + strPeriodName + " type." // ); // } // else if ((bAdvancePeriodType) && (iPeriodStartType == PERIOD_START_TYPE_NONE)) // { // if (messageException == null) // { // messageException = new OSSInvalidDataException(); // } // messageException.getErrorMessages().addMessage( // PERIOD_TYPE_OBJ, // "You have to set valid period start type for " + strPeriodName + " type." // ); // } // else if ((bAdvancePeriodType) // && (iPeriodStartType == PERIOD_START_TYPE_DYNAMIC) // && (iAttributeId == DataObject.NEW_ID)) // { // if (messageException == null) // { // messageException = new OSSInvalidDataException(); // } // messageException.getErrorMessages().addMessage( // PERIOD_TYPE_OBJ, // "You have to set valid period dynamic start attribute for " // + strPeriodName + " type." // ); // } // } // } }