001: package com.calipso.common;
002:
003: import com.calipso.reportgenerator.common.InfoException;
004:
005: import java.util.*;
006: import java.text.*;
007: import java.io.Serializable;
008: import com.calipso.reportgenerator.reportcalculator.SharedDate;
009: import com.calipso.reportgenerator.common.LanguageTraslator;
010:
011: /**
012: * Representa una fecha con sus formatos
013: */
014: public class DateEx implements Serializable, Comparable {
015: //NOTA: Es necesario hacer el new ArrayList, ya que luego se utilizara el add(index, object), no soportado por la lista de Arrays.asList()
016: private static final List possiblePatterns = new ArrayList(Arrays
017: .asList(new Object[] { "yyyyMMdd", "yyyyMMddHHmmssSSS" }));
018:
019: private Date date;
020:
021: public DateEx(Object object) throws InfoException {
022: setDateFromObject(object, "");
023: }
024:
025: private void setDateFromObject(Object date, String inputFormat)
026: throws InfoException {
027: Date newDate = null;
028: if (date instanceof Date) {
029: newDate = (Date) date;
030: } else if (date instanceof String) {
031: String localDate = ((String) date).trim();
032: newDate = getDateFromString(localDate, inputFormat);
033: } else {
034: String localDate = date.toString();
035: newDate = getDateFromString(localDate, inputFormat);
036: }
037: if (newDate != null) {
038: this .date = newDate;
039: } else {
040: throw new InfoException(LanguageTraslator.traslate("77"));
041: }
042: }
043:
044: public DateEx(Date date) {
045: this .date = date;
046: }
047:
048: public DateEx(Object date, String inputFormat) throws InfoException {
049: setDateFromObject(date, inputFormat);
050: }
051:
052: /**
053: * Este constructor genera el Date a partir de un double.
054: * Primero trata de crearlo a partir de la conversion a string del numero,
055: * respetando el input format del DataSourceDefinition.
056: * Luego, si ese no se pudo completar intenta con el formato de fechas de Microsoft,
057: * por si es un double pasado desde un data source excel.
058: * @param date
059: * @param inputFormat
060: * @throws InfoException
061: */
062: public DateEx(Number date, String inputFormat) throws InfoException {
063: Format numberFormat = new DecimalFormat("#####################");
064: String value = numberFormat.format(date);
065: try {
066: setDateFromObject(value, inputFormat);
067: } catch (InfoException e) {
068: DateFormat dateFormat = new SimpleDateFormat("yyyyMMdd");
069: Date expiration;
070: try {
071: expiration = dateFormat.parse("18991230");
072: } catch (ParseException e1) {
073: throw new InfoException(LanguageTraslator
074: .traslate("77"), e1);
075: }
076: GregorianCalendar gregorianCalendar = new GregorianCalendar();
077: gregorianCalendar.setTime(expiration);
078: gregorianCalendar.add(GregorianCalendar.DAY_OF_YEAR,
079: (new Integer(value)).intValue());
080: this .date = gregorianCalendar.getTime();
081: }
082: }
083:
084: /**
085: * Este metodo trata de obtener un Date de un String realizando "parse" varias veces, con cada formato definido.
086: * Los formatos estaran definidos por el parametro inputFormat, por los formatos comunes definidos en la variable local
087: * possiblePatterns. Por ultimo se utiliza el formato que se obtiene del Locale, obtenido de LanguageTranslator.getLocal().
088: * Si todos los parse fallan, se retornara null.
089: * @param localDate El String a parsear
090: * @param inputFormat El formato con el que se espera recibir la fecha. Puede ser null o ""
091: * @return Una fecha si funciono algun Parse. Null en caso contrario
092: */
093: private Date getDateFromString(String localDate, String inputFormat) {
094: Date result = null;
095: if (inputFormat != null && !inputFormat.equalsIgnoreCase("")) {
096: setFirst(possiblePatterns, inputFormat);
097: }
098: for (Iterator iterator = possiblePatterns.iterator(); result == null
099: && iterator.hasNext();) {
100: String pattern = (String) iterator.next();
101: DateFormat format = new SimpleDateFormat(pattern);
102: format.setLenient(false);
103: try {
104: result = format.parse(localDate);
105: } catch (ParseException e) {
106: //Continuar con el siguiente formato
107: }
108: }
109: if (result == null) {
110: DateFormat format = SimpleDateFormat.getDateInstance(
111: DateFormat.SHORT, LanguageTraslator.getLocale());
112: try {
113: format.parse(localDate);
114: } catch (ParseException e) {
115: //Retorna null
116: }
117: }
118: return result;
119: }
120:
121: private void setFirst(List posiblepatterns, String inputFormat) {
122: if (posiblepatterns.contains(inputFormat)) {
123: posiblepatterns.remove(inputFormat);
124: }
125: Object tmp = posiblepatterns.get(0);
126: if (!inputFormat.equals(tmp)) {
127: posiblepatterns.set(0, inputFormat);
128: posiblepatterns.add(tmp);
129: }
130: }
131:
132: public String toString() {
133: SimpleDateFormat dateFormat = (SimpleDateFormat) SimpleDateFormat
134: .getDateInstance(DateFormat.SHORT, LanguageTraslator
135: .getLocale());//new SimpleDateFormat(LanguageTraslator.getLocale().getd);
136: return new String(dateFormat.format((date)));
137: }
138:
139: public Date getDate() {
140: return date;
141: }
142:
143: public int compareTo(Object o) {
144: if (o instanceof DateEx) {
145: return date.compareTo(((DateEx) o).getDate());
146: } else {
147: if (o instanceof SharedDate) {
148: return date.compareTo(((SharedDate) o).getDateEx()
149: .getDate());
150: } else {
151: if (o instanceof Date) {
152: return date.compareTo(((Date) o));
153: } else {
154: if (o instanceof String) {
155: //Date localDate;
156: //DateFormat dateFormat;
157: //dateFormat = new SimpleDateFormat("yyyyMMdd");
158: try {
159: DateEx localDate = new DateEx(o, "");
160: //localDate = dateFormat.parse((String) o);
161: return date.compareTo(localDate.getDate());
162: } catch (Exception e) {
163: return -1;
164: }
165: }
166: }
167: }
168: }
169: return -1;
170: }
171:
172: public boolean equals(Object o) {
173: return ((DateEx) o).getDate().equals(date);
174: }
175:
176: /*public String toNumberFormat() {
177: DateFormat dateFormat;
178: if(inputFormat!=null && !inputFormat.equalsIgnoreCase("")){
179: dateFormat = new SimpleDateFormat(inputFormat);
180: } else {
181: dateFormat = new SimpleDateFormat("yyyyMMdd");
182: }
183: return dateFormat.format(date);
184: }*/
185:
186: }
|