// @VisibleForTesting
DateTime getNthDOWOfMonth(DateTime midnightTomorrow, Integer nthOfMonth, Integer dow) {
int dtconstDow = dow == 0 ? 7 : dow;
DateTime first = midnightTomorrow.withDayOfMonth(1);
if (first.getDayOfWeek() > dtconstDow) {
return first.plusWeeks(nthOfMonth).withDayOfWeek(dtconstDow);
} else {
return first.plusWeeks(nthOfMonth - 1).withDayOfWeek(dtconstDow);
}
}
private RunTimeElements getNextSingleStarts(DateTime baseDate) {
DateTimeFormatter fmtDate = DateTimeFormat.forPattern("yyyy-MM-dd");
DateTimeFormatter fmtDateTime = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");
RunTimeElements result = new RunTimeElements(baseDate);
logger.debug(getDay().size() + " day elements detected.");
Iterator<String> it = getDay().iterator();
while (it.hasNext()) {
String dayString = it.next();
logger.debug("parsing day string " + dayString);
List<Integer> days = JodaTools.getJodaWeekdays(dayString);
for (int i = 0; i < days.size(); i++) {
DateTime nextWeekDay = JodaTools.getNextWeekday(baseDate, days.get(i));
logger.debug("calculated date " + fmtDate.print(nextWeekDay));
List<Period> periods = getPeriod();
Iterator<Period> itP = periods.iterator();
logger.debug(periods.size() + " periods found.");
while (itP.hasNext()) {
Period p = itP.next();
JSObjPeriod period = new JSObjPeriod(objFactory);
period.setObjectFieldsFrom(p);
DateTime start = period.getDtSingleStartOrNull(nextWeekDay);
if (start != null) {
logger.debug("start from period " + fmtDateTime.print(start));
if (start.isBefore(baseDate)) {
start = start.plusWeeks(1);
logger.debug("start is corrected to " + fmtDateTime.print(start));
}
result.add(new RunTimeElement(start, period.getWhenHoliday()));
}
}
}
// Collections.sort(result, DateTimeComparator.getInstance());
}
return result;
}
public Interval getInterval() {
final DateTime beginningOfSemester = new DateTime(getAttends().getBegginingOfLessonPeriod());
final DateTime firstMonday = beginningOfSemester.withField(DateTimeFieldType.dayOfWeek(), 1);
final DateTime start =
firstMonday.withFieldAdded(DurationFieldType.weeks(), getWeekOffset().intValue());
final DateTime end = start.plusWeeks(1);
return new Interval(start, end);
}
private List<DateTime> shiftByOneWeek(List<DateTime> dates) {
List<DateTime> pushedOutSchedule = new ArrayList<DateTime>();
for (DateTime date : dates) {
pushedOutSchedule.add(date.plusWeeks(1));
}
return pushedOutSchedule;
}
private static TimeBox generateTimeSpanForWeek(Integer unit, Clock clock) {
DateTime start;
DateTime end;
start = clock.getTime().withDayOfWeek(1).withTime(0, 0, 0, 0);
end = clock.createDate(start.plusWeeks(unit - 1).withDayOfWeek(5).withTime(23, 59, 59, 99));
return new TimeBox(start, end);
}
public static TimeBox generateLastWeek(Clock clock) {
DateTime start;
DateTime end;
start = clock.getTime().minusWeeks(1).withDayOfWeek(1).withTime(0, 0, 0, 0);
end = clock.createDate(start.plusWeeks(1).minusDays(1).withTime(23, 59, 59, 99));
return new TimeBox(start, end);
}
@Test
public void shouldBeAbleToOutputNiceTimeDeltaForDatesInTheFuture() throws Exception {
final DateTime now = new DateTime();
DateTime fiveMinutesFromNow = now.plusMinutes(5).plusSeconds(5);
assertEquals("5 minutes", dateFormatter.timeSince(fiveMinutesFromNow.toDate()));
DateTime twoDaysFromNow = now.plusDays(2).plusHours(1);
assertEquals("2 days", dateFormatter.timeSince(twoDaysFromNow.toDate()));
DateTime oneWeekFromNow = now.plusWeeks(1).plusHours(1);
assertEquals("1 week", dateFormatter.timeSince(oneWeekFromNow.toDate()));
DateTime twoWeeksFromNow = now.plusWeeks(2).plusHours(1);
assertEquals("2 weeks", dateFormatter.timeSince(twoWeeksFromNow.toDate()));
DateTime sixMonthsFromNow = now.plusMonths(6).plusHours(1);
assertEquals("6 months", dateFormatter.timeSince(sixMonthsFromNow.toDate()));
}
public static Set<String> getMondaySet() {
DateTime startDate = new DateTime(2015, 9, 28, 0, 0);
Date date = new Date();
DateTime endDate = new DateTime(date);
DateTimeFormatter dateFormatter = DateTimeFormat.forPattern("yyyy/MM/dd");
HashSet<String> mondaySet = new HashSet<String>();
while (startDate.isBefore(endDate)) {
mondaySet.add(dateFormatter.print(startDate));
startDate = startDate.plusWeeks(1);
}
return mondaySet;
}
@Test
public void add_weeks_to_date_in_java_with_joda() {
DateTime xmas = new DateTime(2012, 12, 25, 0, 0, 0, 0);
DateTime newYearsDay = xmas.plusWeeks(1);
DateTimeFormatter fmt = DateTimeFormat.forPattern("MM/dd/yyyy HH:mm:ss z");
logger.info(xmas.toString(fmt));
logger.info(newYearsDay.toString(fmt));
assertTrue(newYearsDay.isAfter(xmas));
}
private DateTime nextRepeatWeekly(DateTime midnightNextDay) {
if (schedule.getRepeatRate() == 1) {
return midnightNextDay;
}
int distanceBetweenStartAndTomorrow =
Weeks.weeksBetween(new DateTime(schedule.getBeginDate()).toDateMidnight(), midnightNextDay)
.getWeeks();
if (distanceBetweenStartAndTomorrow == 0
|| distanceBetweenStartAndTomorrow == schedule.getRepeatRate()) {
if ((distanceBetweenStartAndTomorrow == 0
&& midnightNextDay.getDayOfWeek()
<= new DateMidnight(schedule.getBeginDate()).getDayOfWeek())) {
// we crossed a week boundary, so add one week.
return midnightNextDay.plusWeeks(schedule.getRepeatRate() - 1);
}
return midnightNextDay;
} else if (distanceBetweenStartAndTomorrow > schedule.getRepeatRate()) {
int remainder = distanceBetweenStartAndTomorrow % schedule.getRepeatRate();
return midnightNextDay.plusWeeks(schedule.getRepeatRate() - remainder);
} else {
return midnightNextDay.plusWeeks(schedule.getRepeatRate() - distanceBetweenStartAndTomorrow);
}
}
@Override
public RunTimeElements getRunTimeElements(Interval timeRange) {
RunTimeElements result = new RunTimeElements(timeRange);
RunTimeElements work = getNextSingleStarts(timeRange.getStart());
for (RunTimeElement runtime : work.values()) {
DateTime date = runtime.getStartDate();
if (timeRange.contains(date)) {
while (timeRange.contains(date)) {
result.add(new RunTimeElement(date, runtime.getWhenHoliday()));
date = date.plusWeeks(1);
}
}
}
// Collections.sort(result, DateTimeComparator.getInstance());
return result;
}
public static Date getDateFromDateDesc(String leadTime) {
DateTime dateTime = new DateTime(0, 12, 31, 0, 0, 0, 0);
if (!Strings.isEmpty(leadTime)) {
String time = "0";
if (leadTime.indexOf(".") > 0) {
time = leadTime.substring(0, leadTime.indexOf("."));
} else {
time = leadTime.substring(0, leadTime.length() - 1);
}
int timeVal = Integer.parseInt(time);
if (leadTime.indexOf(DAY) >= 0) {
if (timeVal > 0) {
dateTime = dateTime.plusDays(timeVal);
} else {
dateTime = dateTime.minusDays(Math.abs(timeVal));
}
} else if (leadTime.indexOf(WEEK) >= 0) {
if (timeVal > 0) {
dateTime = dateTime.plusWeeks(timeVal);
} else {
dateTime = dateTime.minusWeeks(Math.abs(timeVal));
}
} else if (leadTime.indexOf(MONTH) >= 0) {
if (timeVal > 0) {
dateTime = dateTime.plusMonths(timeVal);
} else {
dateTime = dateTime.minusMonths(Math.abs(timeVal));
}
} else if (leadTime.indexOf(QUARTER) >= 0) {
if (timeVal > 0) {
dateTime = dateTime.plusMonths(timeVal * 3);
} else {
dateTime = dateTime.minusMonths(Math.abs(timeVal * 3));
}
} else if (leadTime.indexOf(YEAR) >= 0) {
if (timeVal > 0) {
dateTime = dateTime.plusYears(timeVal);
} else {
dateTime = dateTime.minusYears(Math.abs(timeVal));
}
}
return dateTime.toDate();
}
return dateTime.toDate();
}
// Check whether the ending date of the task is within one week from now
public boolean isWithinOneWeek(Task t) {
DateTime now = new DateTime();
DateTime weekAfter = now.plusDays(7);
if (t.getType().equals(Constants.TYPE_RECUR)) {
ArrayList<DateTime> dates = t.getRecurDates();
for (DateTime date : dates) {
if (date.isAfter(now) && date.isBefore(weekAfter)) {
return true;
}
}
return false;
} else if (t.getType().equals(Constants.TYPE_FLOATING)) {
return true;
} else {
if (t.getEndingTime().isAfter(now.plusWeeks(1))) {
return false;
} else {
return true;
}
}
}
/**
* 计算指定时间之后的日期
*
* @param date 待计算时间
* @param random 待计算数
* @param timeType 时间类型枚举
* @see org.codingsills.modules.utils.DateKit.TimeType
* @return Date
*/
public static Date nextDate(Date date, int random, TimeType timeType) {
Date nextDate = null;
if (date == null) {
return nextDate;
}
DateTime dateTime = fromDate(date);
random = Math.abs(random);
switch (timeType.getCode()) {
case "Y":
nextDate = dateTime.plusYears(random).toDate();
break;
case "M":
nextDate = dateTime.plusMonths(random).toDate();
break;
case "W":
nextDate = dateTime.plusWeeks(random).toDate();
break;
case "D":
nextDate = dateTime.plusDays(random).toDate();
break;
case "H":
nextDate = dateTime.plusHours(random).toDate();
break;
case "MIN":
nextDate = dateTime.plusMinutes(random).toDate();
break;
case "S":
nextDate = dateTime.plusSeconds(random).toDate();
break;
case "MS":
nextDate = dateTime.plusMillis(random).toDate();
break;
default:
break;
}
return nextDate;
}
@Test
public void testDate() {
DateTime dt = DateTime.now().millisOfDay().withMinimumValue();
;
System.out.println(JodatimeUtils.formatDateTime(dt.toDate()));
DateTime date = JodatimeUtils.parse("2015-03-18");
System.out.println("date: " + date.getDayOfMonth());
Assert.assertEquals(18, date.getDayOfMonth());
date = JodatimeUtils.parse("2016-04-13");
System.out.println("week: " + date.getWeekOfWeekyear());
Assert.assertEquals(15, date.getWeekOfWeekyear());
DateTime dateTime = DateTime.parse("2016-04-13");
System.out.println("dateTime:" + dateTime);
DateTime start = dateTime.dayOfWeek().withMinimumValue();
DateTime end = start.plusWeeks(1);
System.out.println("start:" + start);
System.out.println("end:" + end);
Assert.assertEquals("2016-04-11", start.toString("yyyy-MM-dd"));
Assert.assertEquals("2016-04-18", end.toString("yyyy-MM-dd"));
start = dateTime.dayOfMonth().withMinimumValue();
end = start.plusMonths(1);
System.out.println("start:" + start);
System.out.println("end:" + end);
Assert.assertEquals("2016-04-01", start.toString("yyyy-MM-dd"));
Assert.assertEquals("2016-05-01", end.toString("yyyy-MM-dd"));
start = dateTime.dayOfYear().withMinimumValue();
end = start.plusYears(1);
System.out.println("start:" + start);
System.out.println("end:" + end);
Assert.assertEquals("2016-01-01", start.toString("yyyy-MM-dd"));
Assert.assertEquals("2017-01-01", end.toString("yyyy-MM-dd"));
}
