1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.core.impl.datetime;
17
18 import org.apache.commons.lang.StringUtils;
19 import org.apache.commons.lang.time.DurationFormatUtils;
20 import org.kuali.rice.core.api.datetime.DateTimeService;
21 import org.kuali.rice.core.api.CoreConstants;
22 import org.kuali.rice.core.api.config.property.ConfigContext;
23 import org.springframework.beans.factory.InitializingBean;
24
25 import java.sql.Timestamp;
26 import java.text.DateFormat;
27 import java.text.ParseException;
28 import java.text.ParsePosition;
29 import java.text.SimpleDateFormat;
30 import java.util.Arrays;
31 import java.util.Calendar;
32 import java.util.Collections;
33 import java.util.Date;
34 import java.util.List;
35
36
37
38
39
40
41 public class DateTimeServiceImpl implements DateTimeService, InitializingBean {
42 protected String[] stringToDateFormats;
43 protected String[] stringToTimestampFormats;
44 protected String dateToStringFormatForUserInterface;
45 protected String timestampToStringFormatForUserInterface;
46 protected String dateToStringFormatForFileName;
47 protected String timestampToStringFormatForFileName;
48
49
50
51
52
53 public String toDateString(Date date) {
54 return toString(date, dateToStringFormatForUserInterface);
55 }
56
57
58
59
60 public String toDateTimeString(Date date) {
61 return toString(date, timestampToStringFormatForUserInterface);
62 }
63
64
65
66
67
68 public String toString(Date date, String pattern) {
69 DateFormat dateFormat = new SimpleDateFormat(pattern);
70 dateFormat.setLenient(false);
71 return dateFormat.format(date);
72 }
73
74
75
76
77 public Date getCurrentDate() {
78 Calendar c = Calendar.getInstance();
79 c.setTime(new Date());
80 return c.getTime();
81 }
82
83
84
85
86 public Timestamp getCurrentTimestamp() {
87 return new java.sql.Timestamp(getCurrentDate().getTime());
88 }
89
90
91
92
93 public java.sql.Date getCurrentSqlDate() {
94 return new java.sql.Date(getCurrentDate().getTime());
95 }
96
97
98
99
100 public java.sql.Date getCurrentSqlDateMidnight() {
101
102 return java.sql.Date.valueOf(getCurrentSqlDate().toString());
103 }
104
105
106
107
108 public Calendar getCurrentCalendar() {
109 return getCalendar(getCurrentDate());
110 }
111
112
113
114
115 public Calendar getCalendar(Date date) {
116 if (date == null) {
117 throw new IllegalArgumentException("invalid (null) date");
118 }
119
120 Calendar currentCalendar = Calendar.getInstance();
121 currentCalendar.setTime(date);
122
123 return currentCalendar;
124 }
125
126
127
128
129
130
131 public Date convertToDate(String dateString) throws ParseException {
132 return parseAgainstFormatArray(dateString, stringToDateFormats);
133 }
134
135
136
137
138 public Date convertToDateTime(String dateTimeString) throws ParseException {
139 if (StringUtils.isBlank(dateTimeString)) {
140 throw new IllegalArgumentException("invalid (blank) date/time string");
141 }
142 return parseAgainstFormatArray(dateTimeString, stringToTimestampFormats);
143 }
144
145
146
147
148 public java.sql.Timestamp convertToSqlTimestamp(String timeString)
149 throws ParseException {
150 if (!StringUtils.isBlank(timeString)) {
151 return new java.sql.Timestamp(convertToDateTime(timeString).getTime());
152 }
153 return null;
154 }
155
156
157
158
159 public java.sql.Date convertToSqlDate(String dateString)
160 throws ParseException {
161 if (StringUtils.isBlank(dateString)) {
162 throw new IllegalArgumentException("invalid (blank) timeString");
163 }
164 Date date = parseAgainstFormatArray(dateString, stringToDateFormats);
165 return new java.sql.Date(date.getTime());
166 }
167
168 protected Date parseAgainstFormatArray(String dateString, String[] formats) throws ParseException {
169 dateString = dateString.trim();
170 StringBuffer exceptionMessage = new StringBuffer("Date or date/time string '")
171 .append(dateString)
172 .append("' could not be converted using any of the accepted formats: ");
173 for (String dateFormatString : formats) {
174 try {
175 return parse(dateString, dateFormatString);
176 } catch (ParseException e) {
177 exceptionMessage.append(dateFormatString).append(
178 " (error offset=").append(e.getErrorOffset()).append(
179 "),");
180 }
181 }
182 throw new ParseException(exceptionMessage.toString().substring(0,
183 exceptionMessage.length() - 1), 0);
184 }
185
186
187
188
189
190 public java.sql.Date convertToSqlDate(Timestamp timestamp)
191 throws ParseException {
192 return new java.sql.Date(timestamp.getTime());
193 }
194
195 public int dateDiff(Date startDate, Date endDate, boolean inclusive) {
196 Calendar startDateCalendar = Calendar.getInstance();
197 startDateCalendar.setTime(startDate);
198
199 Calendar endDateCalendar = Calendar.getInstance();
200 endDateCalendar.setTime(endDate);
201
202 int startDateOffset = -(startDateCalendar.get(Calendar.ZONE_OFFSET) + startDateCalendar
203 .get(Calendar.DST_OFFSET))
204 / (60 * 1000);
205
206 int endDateOffset = -(endDateCalendar.get(Calendar.ZONE_OFFSET) + endDateCalendar
207 .get(Calendar.DST_OFFSET))
208 / (60 * 1000);
209
210 if (startDateOffset > endDateOffset) {
211 startDateCalendar.add(Calendar.MINUTE, endDateOffset
212 - startDateOffset);
213 }
214
215 if (inclusive) {
216 startDateCalendar.add(Calendar.DATE, -1);
217 }
218
219 int dateDiff = Integer.parseInt(DurationFormatUtils.formatDuration(
220 endDateCalendar.getTimeInMillis()
221 - startDateCalendar.getTimeInMillis(), "d", true));
222
223 return dateDiff;
224 }
225
226 protected Date parse(String dateString, String pattern) throws ParseException {
227 if (!StringUtils.isBlank(dateString)) {
228 DateFormat dateFormat = new SimpleDateFormat(pattern);
229 dateFormat.setLenient(false);
230 ParsePosition parsePosition = new ParsePosition(0);
231 Date testDate = dateFormat.parse(dateString, parsePosition);
232
233
234 if (testDate == null) {
235 throw new ParseException("The date that you provided is invalid.",parsePosition.getErrorIndex());
236 } else if (parsePosition.getIndex() != dateString.length()) {
237 throw new ParseException("The date that you provided is invalid.",parsePosition.getIndex());
238 }
239
240
241 Calendar testCalendar = Calendar.getInstance();
242 testCalendar.setLenient(false);
243 testCalendar.setTime(testDate);
244 if (testCalendar.get(Calendar.YEAR) < 1000 || testCalendar.get(Calendar.YEAR) > 9999) {
245 throw new ParseException("The date that you provided is not between the years 1000 and 9999.",-1);
246 }
247
248 if(testCalendar.get(Calendar.YEAR) == 1970 && !pattern.contains("y".toLowerCase())){
249 Calendar curCalendar = Calendar.getInstance();
250 curCalendar.setTime(new java.util.Date());
251 testCalendar.set(Calendar.YEAR, curCalendar.get(Calendar.YEAR));
252 testDate = testCalendar.getTime();
253 }
254
255 return testDate;
256 }
257 return null;
258 }
259
260
261
262
263 public String toDateStringForFilename(Date date) {
264 SimpleDateFormat dateFormat = new SimpleDateFormat(dateToStringFormatForFileName);
265 return dateFormat.format(date);
266 }
267
268
269
270
271 public String toDateTimeStringForFilename(Date date) {
272 SimpleDateFormat dateFormat = new SimpleDateFormat(timestampToStringFormatForFileName);
273 return dateFormat.format(date);
274 }
275
276
277
278
279
280
281
282
283
284 private List<String> parseConfigValues(String configValue) {
285 if (configValue == null || "".equals(configValue)) {
286 return Collections.emptyList();
287 }
288 return Arrays.asList(configValue.split(";"));
289 }
290
291
292
293
294
295 @Override
296 public void afterPropertiesSet() throws Exception {
297 if (stringToDateFormats == null) {
298 List<String> dateFormatParams = parseConfigValues(ConfigContext.getCurrentContextConfig().getProperty(CoreConstants.STRING_TO_DATE_FORMATS));
299
300 stringToDateFormats = new String[dateFormatParams.size()];
301
302 for (int i = 0; i < dateFormatParams.size(); i++) {
303 String dateFormatParam = dateFormatParams.get(i);
304 if (StringUtils.isBlank(dateFormatParam)) {
305 throw new IllegalArgumentException("Core/All/STRING_TO_DATE_FORMATS parameter contains a blank semi-colon delimited substring");
306 }
307 else {
308
309 new SimpleDateFormat(dateFormatParam);
310 stringToDateFormats[i] = dateFormatParam;
311 }
312 }
313 }
314
315 if (stringToTimestampFormats == null) {
316 List<String> dateFormatParams = parseConfigValues(ConfigContext.getCurrentContextConfig().getProperty(CoreConstants.STRING_TO_TIMESTAMP_FORMATS));
317
318 stringToTimestampFormats = new String[dateFormatParams.size()];
319
320 for (int i = 0; i < dateFormatParams.size(); i++) {
321 String dateFormatParam = dateFormatParams.get(i);
322 if (StringUtils.isBlank(dateFormatParam)) {
323 throw new IllegalArgumentException("Core/All/STRING_TO_TIMESTAMP_FORMATS parameter contains a blank semi-colon delimited substring");
324 }
325 else {
326
327 new SimpleDateFormat(dateFormatParam);
328 stringToTimestampFormats[i] = dateFormatParam;
329 }
330 }
331 }
332
333 if (dateToStringFormatForUserInterface == null) {
334 dateToStringFormatForUserInterface = ConfigContext.getCurrentContextConfig().getProperty(CoreConstants.DATE_TO_STRING_FORMAT_FOR_USER_INTERFACE);
335
336 new SimpleDateFormat(dateToStringFormatForUserInterface);
337 }
338
339 if (timestampToStringFormatForUserInterface == null) {
340 timestampToStringFormatForUserInterface = ConfigContext.getCurrentContextConfig().getProperty(CoreConstants.TIMESTAMP_TO_STRING_FORMAT_FOR_USER_INTERFACE);
341
342 new SimpleDateFormat(timestampToStringFormatForUserInterface);
343 }
344
345 if (dateToStringFormatForFileName == null) {
346 dateToStringFormatForFileName = ConfigContext.getCurrentContextConfig().getProperty(CoreConstants.DATE_TO_STRING_FORMAT_FOR_FILE_NAME);
347
348
349 new SimpleDateFormat(dateToStringFormatForFileName);
350 }
351
352 if (timestampToStringFormatForFileName == null) {
353 timestampToStringFormatForFileName = ConfigContext.getCurrentContextConfig().getProperty(CoreConstants.TIMESTAMP_TO_STRING_FORMAT_FOR_FILE_NAME);
354
355
356 new SimpleDateFormat(timestampToStringFormatForFileName);
357 }
358 }
359 }