TransactionHistoryDataUtil To perform date formats and find the days

/*** Eclipse Class Decompiler plugin, copyright (c) 2012 Chao Chen (cnfree2000@hotmail.com) ***/
package com.benefitfocus.transactionhistory.common.util;

import bf.lang.ObjectUtil;
import com.benefitfocus.transactionhistory.snapshotdata.Identifier;
import com.benefitfocus.transactionhistory.snapshotdata.IdentifierType;
import com.benefitfocus.transactionhistory.snapshotdata.Metadata;
import com.benefitfocus.transactionhistory.snapshotdata.TransitoryCommElement;
import com.benefitfocus.transactionhistory.snapshotdata.TransitoryElement;
import java.math.BigDecimal;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Locale;
import java.util.TimeZone;
import org.apache.commons.lang.StringUtils;

public final class TransactionHistoryDataUtil {
public static final String YEAR_MONTH_DAY_HOUR_SEC = "yyyyMMddhhmmss";
public static final String YEAR_MONTH_DAY_HOUR_SECONDS = "yyyyMMddhhmmssss";
public static final String YEAR_MONTH_DAY_24HOUR_SEC = "yyyyMMddHHmmss";
public static final String YEAR_MONTH_DAY_HOUR_SECONDS_EXTENDED = "yyyyMMdd_hhmmssSSS";
public static final String DAY_MONTH_YEAR_ENROLLMENT = "dd-MM-yy";
public static final String MONTH_DAY_YYYY = "MMddyyyy";
public static final String MONTH_DAY_YYYY_SLASH = "MM/dd/yyyy";
public static final String MONTH_DAY_YYYY_HYPHENATED = "MM-dd-yyyy";
public static final String YYYY_MONTH_DAY = "yyyyMMdd";
public static final String YYYY_MONTH_DAY_HYPHENATED = "yyyy-MM-dd";
public static final String FORMAT_DATETIME_ISO = "yyyy-MM-dd'T'HH:mm:ss.SSSZ";
public static final String ORACLE_SQL_TIMESTAMP = "dd-MMM-yy hh.mm.ss.SSS a";
private static final List<String> dateFormatList = new ArrayList();

public static Date getFormattedDate(String format) throws ParseException {
return getFormattedDate(format, new Date());
}

public static Date addDays(Date date, int daysToAdd) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(5, daysToAdd);
return cal.getTime();
}

public static Date subtractDays(Date date, int daysToSubtract) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(5, -daysToSubtract);
return cal.getTime();
}

public static Date addMinutes(Date date, int minutesToAdd) {
Calendar cal = Calendar.getInstance();
cal.setTime(date);
cal.add(12, minutesToAdd);
return cal.getTime();
}

public static boolean isDateBetween(Date startDate, Date endDate,
Date targetDate) {
if ((startDate == null) || (endDate == null) || (targetDate == null)
|| (endDate.before(startDate))) {
return false;
}

boolean result = false;
if ((targetDate.compareTo(startDate) == 0)
&& (targetDate.compareTo(endDate) < 0))
result = true;
else if ((targetDate.compareTo(endDate) == 0)
&& (targetDate.compareTo(startDate) > 0))
result = true;
else if (targetDate.compareTo(startDate)
* endDate.compareTo(targetDate) > 0) {
result = true;
}

return result;
}

public static Date today() {
Date today = new Date();
return zero(today);
}

public static Date zero(Date date) {
if (date != null) {
Calendar myCal = Calendar.getInstance(Locale.US);
myCal.setTime(date);
myCal.set(11, 0);
myCal.set(12, 0);
myCal.set(13, 0);
myCal.set(14, 0);
return myCal.getTime();
}
return date;
}

public static String addDays(String format, String date, int daysToAdd)
throws ParseException {
Calendar cal = Calendar.getInstance();
cal.setTime(getFormattedDate(format, date));
cal.add(5, daysToAdd);
return getFormattedDateString(format, cal.getTime());
}

public static Date addDaysDate(String format, String date, int daysToAdd)
throws ParseException {
Calendar cal = Calendar.getInstance();
cal.setTime(getFormattedDate(format, date));
cal.add(5, daysToAdd);
return getFormattedDate(format, cal.getTime());
}

public static Date addYears(Date date, int years) {
Calendar calendar = Calendar.getInstance();
calendar.setTime(date);

boolean originalDateWasEndOfMonth = calendar.getActualMaximum(5) == calendar
.get(5);

calendar.add(1, years);

if (originalDateWasEndOfMonth) {
boolean currentDateIsEndOfMonth = calendar.getActualMaximum(5) == calendar
.get(5);

if (!(currentDateIsEndOfMonth)) {
calendar.set(5, calendar.getActualMaximum(5));
}
}

return calendar.getTime();
}

public static boolean isOlderThan(Date dateOfBirth, int age, Date asOfDate) {
Date dateTurnedRequestedAge = addYears(dateOfBirth, age);
return dateTurnedRequestedAge.before(asOfDate);
}

public static String getFormattedDateString(String format)
throws ParseException {
return getFormattedDateString(format, getFormattedDate(format));
}

public static String getFormattedDateString(String format, Date date) {
if ("yyyy-MM-dd'T'HH:mm:ss.SSSZ".equalsIgnoreCase(format)) {
DateFormat simpleDateFormat = new SimpleDateFormat(
"yyyy-MM-dd'T'HH:mm:ss.SSSZ");
simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
return simpleDateFormat.format(date);
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
return simpleDateFormat.format(date);
}

public static String getSQLFormattedDateTime(Date date) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(
"dd-MMM-yy hh.mm.ss.SSS a");
return simpleDateFormat.format(date);
}

public static String getFormattedDateString(String format, String date)
throws ParseException {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
Date parsedDate = simpleDateFormat.parse(date.toString());
return simpleDateFormat.format(parsedDate);
}

public static Date getFormattedDate(String format, String date)
throws ParseException {
if ("yyyy-MM-dd'T'HH:mm:ss.SSSZ".equalsIgnoreCase(format)) {
DateFormat simpleDateFormat = new SimpleDateFormat(
"yyyy-MM-dd'T'HH:mm:ss.SSSZ");
simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
return simpleDateFormat.parse(date);
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
return simpleDateFormat.parse(date);
}

public static Date getFormattedDate(String format, Date date)
throws ParseException {
if ("yyyy-MM-dd'T'HH:mm:ss.SSSZ".equalsIgnoreCase(format)) {
DateFormat simpleDateFormat = new SimpleDateFormat(
"yyyy-MM-dd'T'HH:mm:ss.SSSZ");
simpleDateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
return simpleDateFormat.parse(simpleDateFormat.format(date));
}
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
return simpleDateFormat.parse(simpleDateFormat.format(date));
}

@Deprecated
public static Date getDate(String date) {
Date formattedDate = null;
if (date != null) {
for (String format : dateFormatList) {
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(format);
try {
simpleDateFormat.setLenient(false);
formattedDate = simpleDateFormat.parse(date.toString());
} catch (ParseException localParseException) {
}
}
}

return formattedDate;
}

public static boolean before(TransitoryElement date1,
TransitoryElement date2, String dateFormat) throws ParseException {
return ((transitoryElementHasNonEmptyValue(date1))
&& (transitoryElementHasNonEmptyValue(date2)) && (before(
date1.getValue(), date2.getValue(), dateFormat)));
}

public static boolean after(TransitoryElement date1,
TransitoryElement date2, String dateFormat) throws ParseException {
return ((transitoryElementHasNonEmptyValue(date1))
&& (transitoryElementHasNonEmptyValue(date2)) && (after(
date1.getValue(), date2.getValue(), dateFormat)));
}

public static boolean before(String date1, String date2, String dateFormat)
throws ParseException {
if ((date1 == null) || (date2 == null)) {
return false;
}

return before(getFormattedDate(dateFormat, date1),
getFormattedDate(dateFormat, date2));
}

public static boolean after(String date1, String date2, String dateFormat)
throws ParseException {
if ((date1 == null) || (date2 == null)) {
return false;
}

return after(getFormattedDate(dateFormat, date1),
getFormattedDate(dateFormat, date2));
}

public static boolean before(Date date1, Date date2) {
if ((date1 == null) || (date2 == null)) {
return false;
}

return (compare(date1, date2) < 0);
}

public static boolean after(Date date1, Date date2) {
if ((date1 == null) || (date2 == null)) {
return false;
}

return (compare(date1, date2) > 0);
}

public static int daysDifferentBetweenDates(Date earlier, Date later) {
if ((earlier == null) || (later == null))
return 0;
return (int) (later.getTime() / 86400000L - (earlier.getTime() / 86400000L));
}

public static int compare(Date date1, Date date2) {
if ((ObjectUtil.isEmpty(date1)) && (ObjectUtil.isEmpty(date2)))
return 0;
if ((ObjectUtil.isEmpty(date1) ^ ObjectUtil.isEmpty(date2))) {
return ((ObjectUtil.isEmpty(date1)) ? -1 : 1);
}
Date d1 = zero(date1);
Date d2 = zero(date2);

return d1.compareTo(d2);
}

public static boolean transitoryElementHasNonEmptyValue(
TransitoryElement element) {
return ((element != null) && (element.getValue() != null) && (!(element
.getValue().trim().equals(""))));
}

public static boolean transitoryCommElementHasNonEmptyValue(
TransitoryCommElement element) {
return ((element != null) && (element.getValue() != null) && (!(element
.getValue().trim().equals(""))));
}

public static boolean isTransitoryElementValueEmptyOrNull(
TransitoryElement element) {
return ((element == null) || (element.getValue() == null));
}

public static boolean isTransitoryElementPreviousEmptyOrNull(
TransitoryElement element) {
return ((element == null) || (element.getPrevious() == null));
}

public static boolean isTransitoryCommElementValueEmptyOrNull(
TransitoryCommElement element) {
return ((element == null) || (element.getValue() == null));
}

public static boolean isTransitoryCommElementPreviousEmptyOrNull(
TransitoryCommElement element) {
return ((element == null) || (element.getPrevious() == null));
}

public static TransitoryElement generateTransitoryElement(
String stringValue, String previousValue) {
TransitoryElement transitoryElement = new TransitoryElement();
transitoryElement.setValue(stringValue);
if (previousValue != null) {
transitoryElement.setPrevious(previousValue);
}
return transitoryElement;
}

public static String getTransitoryElementPreviousAsString(
TransitoryElement element, String defaultVal) {
if ((element != null) && (element.getPrevious() != null)
&& (element.getPrevious().trim().length() > 0)) {
return element.getPrevious();
}

return defaultVal;
}

public static String getTransitoryElementAsString(
TransitoryElement element, String defaultValue) {
if ((element == null) || (element.getValue() == null)) {
return defaultValue;
}
return element.getValue();
}

public static Boolean isTransitoryElementValueEqual(
TransitoryElement element1, TransitoryElement element2) {
if ((element1 == null) && (element2 == null)) {
return Boolean.valueOf(true);
}
if ((element1 == null) || (element2 == null)) {
return Boolean.valueOf(false);
}
return Boolean.valueOf(StringUtils.equals(element1.getValue(),
element2.getValue()));
}

public static Boolean isTransitoryElementPreviousEqual(
TransitoryElement element1, TransitoryElement element2) {
if ((element1 == null) && (element2 == null)) {
return Boolean.valueOf(true);
}
if ((element1 == null) || (element2 == null)) {
return Boolean.valueOf(false);
}
return Boolean.valueOf(StringUtils.equals(element1.getPrevious(),
element2.getPrevious()));
}

public static Boolean isEntireTransitoryElementEqual(
TransitoryElement element1, TransitoryElement element2) {
return Boolean.valueOf((isTransitoryElementPreviousEqual(element1,
element2).booleanValue())
&& (isTransitoryElementValueEqual(element1, element2)
.booleanValue()));
}

public static void addMetadataToMetadataList(List<Metadata> metadataList,
String key, String value) {
if (metadataList != null)
metadataList.add(generateMetadata(key, value));
}

public static void addMetadataToMetadataList(List<Metadata> metadataList,
String key, String value, String startDate, String endDate) {
if (metadataList != null)
metadataList.add(generateMetadata(key, value, startDate, endDate));
}

public static Metadata findMetadataByKey(List<Metadata> metadataList,
String key) {
for (Metadata metaData : metadataList) {
if (key.equals(metaData.getName())) {
return metaData;
}
}
return null;
}

public static Metadata generateMetadata(String key, String value) {
Metadata metaData = new Metadata();
metaData.setName(key);
metaData.setValue(value);
return metaData;
}

public static Metadata generateMetadata(String key, String value,
String startDate, String endDate) {
Metadata metaData = new Metadata();
metaData.setName(key);
metaData.setValue(value);
metaData.setEffectiveDate(startDate);
metaData.setExpirationDate(endDate);
return metaData;
}

public static String getAnnualSalary(String earningsClass, String salary) {
if ((earningsClass != null) && (!(earningsClass.equals("")))
&& (salary != null) && (!(salary.equals("")))) {
BigDecimal numPayChecks = new BigDecimal(
getYearlyPaychecks(earningsClass));
BigDecimal salaryAmt = new BigDecimal(salary);
BigDecimal annualSalary = numPayChecks.multiply(salaryAmt);
return annualSalary.toString();
}
return null;
}

public static int getYearlyPaychecks(String earningsClass) {
String[] year = { "YEAR", "YEARLY", "ANNUAL", "ANNUALLY" };
String[] ten_per_year = { "TEN PER YEAR" };
String[] month = { "MONTH", "MONTHLY" };
String[] sixteen_per_year = { "SIXTEEN PER YEAR" };
String[] twentyone_per_year = { "TWENTYONE PER YEAR" };
String[] halfmonth = { "HALF MONTH", "HALF MONTHLY" };
String[] twoweek = { "TWO WEEKS" };
String[] four_per_month = { "FOUR PER MONTH" };
String[] week = { "WEEK", "WEEKLY" };
String[] hour = { "HOUR", "HOURLY" };

if ((earningsClass == null)
|| (Arrays.asList(year).contains(earningsClass)))
return 1;
if (Arrays.asList(hour).contains(earningsClass))
return 2080;
if (Arrays.asList(week).contains(earningsClass))
return 52;
if (Arrays.asList(four_per_month).contains(earningsClass))
return 48;
if (Arrays.asList(twoweek).contains(earningsClass))
return 26;
if (Arrays.asList(halfmonth).contains(earningsClass))
return 24;
if (Arrays.asList(twentyone_per_year).contains(earningsClass))
return 21;
if (Arrays.asList(sixteen_per_year).contains(earningsClass))
return 16;
if (Arrays.asList(month).contains(earningsClass))
return 12;
if (Arrays.asList(ten_per_year).contains(earningsClass)) {
return 10;
}
return 1;
}

public static Identifier findIdentifierByName(List<Identifier> identifiers,
String identifierName, IdentifierType identifierType) {
if ((identifiers != null) && (identifierName != null)
&& (identifierType != null)) {
for (Identifier identifier : identifiers) {
if ((getTransitoryElementAsString(identifier.getName(), "")
.equalsIgnoreCase(identifierName))
&& (identifier.getIdentifierType() == identifierType)) {
return identifier;
}
}
}

return null;
}

public static Identifier findIdentifierByTypeClassification(
List<Identifier> identifiers, String identifierTypeClassification,
IdentifierType identifierType) {
if ((identifiers != null) && (identifierTypeClassification != null)
&& (identifierType != null)) {
for (Identifier identifier : identifiers) {
if ((identifierTypeClassification.equalsIgnoreCase(identifier
.getIdentifierTypeClassification()))
&& (identifier.getIdentifierType() == identifierType)) {
return identifier;
}
}
}

return null;
}

public static Identifier createCustomIdentifier(String identName,
String identValue) {
if ((identName != null) && (identValue != null)) {
Identifier ident = new Identifier();
ident.setIdentifierType(IdentifierType.CUSTOM);

TransitoryElement identifierTENameElement = generateTransitoryElement(
identName, null);
ident.setName(identifierTENameElement);

TransitoryElement identifierTEValue = generateTransitoryElement(
identValue, null);
ident.setValue(identifierTEValue);

return ident;
}

return null;
}

static {
dateFormatList.add("MMddyyyy");
dateFormatList.add("MM/dd/yyyy");
dateFormatList.add("MM-dd-yyyy");
dateFormatList.add("yyyyMMdd");
dateFormatList.add("yyyy-MM-dd");
dateFormatList.add("dd-MM-yy");
dateFormatList.add("yyyyMMdd_hhmmssSSS");
dateFormatList.add("yyyyMMddhhmmssss");
dateFormatList.add("yyyyMMddhhmmss");
dateFormatList.add("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
dateFormatList.add("dd-MMM-yy hh.mm.ss.SSS a");
}
}