org.joda.time.Days Java Examples

@Override
public long getLong(int field)
{
    checkState(row != null, "No current row");
    Column column = columns.get(field);
    if (column.getType().getBase() == ColumnType.Base.DATE) {
        return Days.daysBetween(new LocalDate(0), LocalDate.parse(row.get(column.getPosition()))).getDays();
    }
    if (column.getType().getBase() == ColumnType.Base.TIME) {
        return LocalTime.parse(row.get(column.getPosition())).getMillisOfDay();
    }
    if (column.getType().getBase() == ColumnType.Base.INTEGER) {
        return parseInt(row.get(column.getPosition()));
    }
    if (column.getType().getBase() == ColumnType.Base.DECIMAL) {
        DecimalParseResult decimalParseResult = Decimals.parse(row.get(column.getPosition()));
        return rescale((Long) decimalParseResult.getObject(), decimalParseResult.getType().getScale(), ((DecimalType) columnTypes.get(field)).getScale());
    }
    return parseLong(row.get(column.getPosition()));
}
 

private String prepareDate(Date date){
    DateTime busTimestamp = new DateTime(date);
    DateTime now = new DateTime(Calendar.getInstance());

    int time = Seconds.secondsBetween(busTimestamp, now).getSeconds();
    if(time < 60) return context.getString(R.string.marker_seconds, String.valueOf(time));

    time = Minutes.minutesBetween(busTimestamp, now).getMinutes();
    if(time < 60) return context.getString(R.string.marker_minutes, String.valueOf(time));

    time = Hours.hoursBetween(busTimestamp, now).getHours();
    if(time < 24) return context.getString(R.string.marker_hours, String.valueOf(time));

    time = Days.daysBetween(busTimestamp, now).getDays();
    return context.getString(R.string.marker_days, String.valueOf(time));
}
 

/**
 * Returns the number of days between two dates.
 */
@Function("DAYS")
@FunctionParameters({
	@FunctionParameter("startDate"),
	@FunctionParameter("endDate")})
public Integer DAYS(Object startDate, Object endDate){
	Date startDateObj = convertDateObject(startDate);
	if(startDateObj==null) {
		logCannotConvertToDate();
		return null;
	}
	Date endDateObj = convertDateObject(endDate);
	if(endDateObj==null){
		logCannotConvertToDate();
		return null;
	}
	else{
		LocalDate dt1=new LocalDate(startDateObj);
		LocalDate dt2=new LocalDate(endDateObj);
		return Days.daysBetween(dt1, dt2).getDays();
	}
}
 

/**
 * 获得两个时间点之间的时间跨度
 * 
 * @param time1
 *            开始的时间点
 * @param time2
 *            结束的时间点
 * @param timeUnit
 *            跨度的时间单位 see {@link JodaTime}
 *            （支持的时间单位有DAY,HOUR,MINUTE,SECOND,MILLI）
 */
public static long lengthBetween(DateTime time1, DateTime time2,
		DurationFieldType timeUnit) {
	Duration duration = Days.daysBetween(time1, time2).toStandardDuration();
	if (timeUnit == JodaTime.DAY) {
		return duration.getStandardDays();
	} else if (timeUnit == JodaTime.HOUR) {
		return duration.getStandardHours();
	} else if (timeUnit == JodaTime.MINUTE) {
		return duration.getStandardMinutes();
	} else if (timeUnit == JodaTime.SECOND) {
		return duration.getStandardSeconds();
	} else if (timeUnit == JodaTime.MILLI) {
		return duration.getMillis();
	} else {
		throw new RuntimeException(
				"TimeUnit not supported except DAY,HOUR,MINUTE,SECOND,MILLI");
	}
}
 

@Override
@SuppressWarnings("EqualsBetweenInconvertibleTypes") // SpecimenType knows how to do equals(Class<?>)
public Object create(Object request, SpecimenContext context) {

    if (!(request instanceof SpecimenType)) {
        return new NoSpecimen();
    }

    SpecimenType type = (SpecimenType) request;
    if (!BaseSingleFieldPeriod.class.isAssignableFrom(type.getRawType())) {
        return new NoSpecimen();
    }

    Duration duration = (Duration) context.resolve(Duration.class);
    if (type.equals(Seconds.class)) return Seconds.seconds(Math.max(1, (int) duration.getStandardSeconds()));
    if (type.equals(Minutes.class)) return Minutes.minutes(Math.max(1, (int) duration.getStandardMinutes()));
    if (type.equals(Hours.class)) return Hours.hours(Math.max(1, (int) duration.getStandardHours()));

    if (type.equals(Days.class)) return Days.days(Math.max(1, (int) duration.getStandardDays()));
    if (type.equals(Weeks.class)) return Weeks.weeks(Math.max(1, (int) duration.getStandardDays() / 7));
    if (type.equals(Months.class)) return Months.months(Math.max(1, (int) duration.getStandardDays() / 30));
    if (type.equals(Years.class)) return Years.years(Math.max(1, (int) duration.getStandardDays() / 365));

    return new NoSpecimen();
}
 

private static String dateToAge(String createdAt, DateTime now) {
    if (createdAt == null) {
        return "";
    }

    DateTimeFormatter dtf = DateTimeFormat.forPattern(DATE_TIME_FORMAT);
    try {
        DateTime created = dtf.parseDateTime(createdAt);

        if (Seconds.secondsBetween(created, now).getSeconds() < 60) {
            return Seconds.secondsBetween(created, now).getSeconds() + "s";
        } else if (Minutes.minutesBetween(created, now).getMinutes() < 60) {
            return Minutes.minutesBetween(created, now).getMinutes() + "m";
        } else if (Hours.hoursBetween(created, now).getHours() < 24) {
            return Hours.hoursBetween(created, now).getHours() + "h";
        } else {
            return Days.daysBetween(created, now).getDays() + "d";
        }
    } catch (IllegalArgumentException e) {
        return "";
    }
}
 

/**
 * Create default auto message for date of anniversary
 */
public Reminder(Date dateEvent, int minuteBeforeEvent) {
    this.id = ID_UNDEFINED;
    this.dateEvent = dateEvent;
    this.dateEvent = new DateTime(this.dateEvent)
            .withHourOfDay(0)
            .withMinuteOfHour(0)
            .withSecondOfMinute(0)
            .withMillisOfSecond(0)
            .toDate();
    DateTime dateReminder = new DateTime(dateEvent).minusMinutes(minuteBeforeEvent);
    this.hourOfDay = dateReminder.getHourOfDay();
    this.minuteOfHour = dateReminder.getMinuteOfHour();
    this.daysBefore = Days.daysBetween(dateReminder, new DateTime(dateEvent)).getDays();
    if(minuteBeforeEvent > 0)
        this.daysBefore++;
}
 

@Override
public Long exec(Tuple input) throws IOException
{
    if (input == null || input.size() < 2) {
        return null;
    }

    if (input.get(0) == null || input.get(1) == null) {
        return null;
    }

    DateTime startDate = new DateTime(input.get(0).toString());
    DateTime endDate = new DateTime(input.get(1).toString());

    // Larger date first
    Days d = Days.daysBetween(endDate, startDate);
    long days = d.getDays();

    return days;

}
 

protected static int dateDiff(Date beginDate, Date endDate, DateType type) {
    //Interval interval = new Interval(beginDate.getTime(), endDate.getTime());
    //Period p = interval.toPeriod();
    DateTime start =new DateTime(beginDate);
    DateTime end =new DateTime(endDate);
    if (DateType.YEAR.equals(endDate)) {
         return Years.yearsBetween(start, end).getYears();
    } else if (DateType.MONTH.equals(type)) {
        return Months.monthsBetween(start, end).getMonths();
    } else if (DateType.WEEK.equals(type)) {
        return Weeks.weeksBetween(start, end).getWeeks();
    } else if (DateType.DAY.equals(type)) {
        return Days.daysBetween(start, end).getDays();
    } else if (DateType.HOUR.equals(type)) {
        return Hours.hoursBetween(start, end).getHours();
    } else if (DateType.MINUTE.equals(type)) {
        return Minutes.minutesBetween(start, end).getMinutes();
    } else if (DateType.SECOND.equals(type)) {
        return Seconds.secondsBetween(start, end).getSeconds();
    } else {
        return 0;
    }
}
 

public TempTablesCleaner(RxSession session, DataAccessImpl dataAccess, String keyspace, int ttl) {
    this.session = session;
    this.dataAccess = dataAccess;
    this.ttl = Days.days(ttl).toStandardDuration().getMillis();

    findTables = session.getSession().prepare(
            "SELECT table_name FROM system_schema.tables WHERE keyspace_name = '" + keyspace + "'");
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceExpiryDays() {
    LocalDate periodDate = new LocalDate();
    int previousPeriodStart = getPreviousPeriodStart();
    periodDate = periodDate.withMonthOfYear(
            previousPeriodStart == PREVIOUS_PERIOD_START_JANUARY ? DateTimeConstants.JANUARY
                    : DateTimeConstants.JULY).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusMonths(6), new LocalDate()).getDays();
    SixMonthlyExpiryDayValidator monthlyExpiryDayValidator = new SixMonthlyExpiryDayValidator(
            expiryDays,
            periodDate.toString(PATTERN) + previousPeriodStart);
    assertFalse(monthlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceMinusOneExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusMonths(1).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusMonths(1), new LocalDate()).getDays() - 1;
    MonthlyExpiryDayValidator monthlyExpiryDayValidator = new MonthlyExpiryDayValidator(
            expiryDays,
            periodDate.toString(PATTERN));
    assertFalse(monthlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferencePlusOneExpiryDays() {
    LocalDate periodDate = new LocalDate();
    int previousPeriodStart = getPreviousPeriodStart();
    periodDate = periodDate.withMonthOfYear(
            previousPeriodStart == PREVIOUS_PERIOD_START_APRIL ? DateTimeConstants.APRIL
                    : DateTimeConstants.OCTOBER).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusMonths(6), new LocalDate()).getDays() + 1;
    SixMonthlyAprilExpiryDayValidator monthlyExpiryDayValidator =
            new SixMonthlyAprilExpiryDayValidator(
                    expiryDays,
                    periodDate.toString(PATTERN) + previousPeriodStart);
    assertFalse(monthlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceMinusOneExpiryDays() {
    LocalDate periodDate = new LocalDate();
    int previousPeriodStart = getPreviousPeriodStart();
    periodDate = periodDate.withMonthOfYear(
            previousPeriodStart == PREVIOUS_PERIOD_START_APRIL ? DateTimeConstants.APRIL
                    : DateTimeConstants.OCTOBER).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusMonths(6), new LocalDate()).getDays() - 1;
    SixMonthlyAprilExpiryDayValidator monthlyExpiryDayValidator =
            new SixMonthlyAprilExpiryDayValidator(
                    expiryDays,
                    periodDate.toString(PATTERN) + previousPeriodStart);
    assertFalse(monthlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusYears(1).withMonthOfYear(
            DateTimeConstants.JANUARY).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusYears(1), new LocalDate()).getDays();
    YearlyExpiryDayValidator yearlyExpiryDayValidator = new YearlyExpiryDayValidator(
            expiryDays,
            periodDate.toString(PATTERN));
    assertFalse(yearlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanEditPreviousPeriodEndsSameTodayMinusExpiryDaysPlusOne() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusWeeks(1).withDayOfWeek(DateTimeConstants.SUNDAY);
    int expiryDays = Days.daysBetween(periodDate.plusDays(6), new LocalDate()).getDays() + 1;
    WeeklySundayExpiryDayValidator weeklyExpiryDayValidator =
            new WeeklySundayExpiryDayValidator(expiryDays,
                    periodDate.toString(PATTERN));
    assertTrue(weeklyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferencePlusOneExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusYears(1).withMonthOfYear(
            DateTimeConstants.JANUARY).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusYears(1), new LocalDate()).getDays() + 1;
    YearlyExpiryDayValidator yearlyExpiryDayValidator = new YearlyExpiryDayValidator(
            expiryDays,
            periodDate.toString(PATTERN));
    assertFalse(yearlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusYears(1).withMonthOfYear(
            DateTimeConstants.OCTOBER).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusYears(1), new LocalDate()).getDays();
    FinancialYearOctExpiryDayValidator yearlyExpiryDayValidator =
            new FinancialYearOctExpiryDayValidator(
                    expiryDays,
                    periodDate.toString(PATTERN));
    assertFalse(yearlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferencePlusOneExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusYears(1).withMonthOfYear(
            DateTimeConstants.OCTOBER).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusYears(1), new LocalDate()).getDays() + 1;
    FinancialYearOctExpiryDayValidator yearlyExpiryDayValidator =
            new FinancialYearOctExpiryDayValidator(
                    expiryDays,
                    periodDate.toString(PATTERN));
    assertFalse(yearlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanEditWithPeriodPreviousMonthWithTwoMoreDaysAtExpiryDays() {
    LocalDate periodDate = new LocalDate();
    int previousPeriodStart = getPreviousPeriodStart();
    periodDate = periodDate.withMonthOfYear(
            previousPeriodStart == PREVIOUS_PERIOD_START_APRIL ? DateTimeConstants.APRIL
                    : DateTimeConstants.OCTOBER).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusMonths(6), new LocalDate()).getDays() + 2;
    SixMonthlyAprilExpiryDayValidator monthlyExpiryDayValidator =
            new SixMonthlyAprilExpiryDayValidator(
                    expiryDays,
                    periodDate.toString(PATTERN) + previousPeriodStart);
    assertTrue(monthlyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusWeeks(1).withDayOfWeek(DateTimeConstants.SUNDAY);
    int expiryDays = Days.daysBetween(periodDate.plusDays(6), new LocalDate()).getDays();
    WeeklySundayExpiryDayValidator weeklyExpiryDayValidator =
            new WeeklySundayExpiryDayValidator(expiryDays,
                    periodDate.toString(PATTERN));
    assertFalse(weeklyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusWeeks(1).withDayOfWeek(DateTimeConstants.SATURDAY);
    int expiryDays = Days.daysBetween(periodDate.plusDays(6), new LocalDate()).getDays();
    WeeklySaturdayExpiryDayValidator weeklyExpiryDayValidator =
            new WeeklySaturdayExpiryDayValidator(expiryDays,
                    periodDate.toString(PATTERN));
    assertFalse(weeklyExpiryDayValidator.canEdit());
}
 

DilbertFragmentAdapter(FragmentManager fm, DilbertPreferences preferences) {
    super(fm);
    this.countCache = Days.daysBetween(
            DilbertPreferences.getFirstStripDate(),
            LocalDate.now()).getDays() + 1;
    this.preferences = preferences;
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceMinusOneExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusWeeks(1).withDayOfWeek(DateTimeConstants.THURSDAY);
    int expiryDays = Days.daysBetween(periodDate.plusDays(6), new LocalDate()).getDays() - 1;
    WeeklyThursdayExpiryDayValidator weeklyExpiryDayValidator =
            new WeeklyThursdayExpiryDayValidator(expiryDays,
                    periodDate.toString(PATTERN));
    assertFalse(weeklyExpiryDayValidator.canEdit());
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusWeeks(1).withDayOfWeek(DateTimeConstants.THURSDAY);
    int expiryDays = Days.daysBetween(periodDate.plusDays(6), new LocalDate()).getDays();
    WeeklyThursdayExpiryDayValidator weeklyExpiryDayValidator =
            new WeeklyThursdayExpiryDayValidator(expiryDays,
                    periodDate.toString(PATTERN));
    assertFalse(weeklyExpiryDayValidator.canEdit());
}
 

public boolean user_validateDateofBirthAndLogin(String login, Date dob)  {
	try {
		User user = userDAO.findByLogin(login);
		if(user == null){
			return false; //login not found
		}
		//check the provided dob against the database	
		int days = Days.daysBetween(new DateTime(user.getDateOfBirth()), new DateTime(dob)).getDays();
		if (days == 0 ) {return true;}	else {return false;	}
	}
	catch (Exception e) {
		log.error(e.getMessage(),e);
		throw (new RuntimeException(e));
	}
}
 

@Test
public void testCanNotEditPreviousPeriodEndsSameTodayMinusDifferenceMinusOneExpiryDays() {
    LocalDate periodDate = new LocalDate();
    periodDate = periodDate.minusYears(1).withMonthOfYear(
            DateTimeConstants.JULY).withDayOfMonth(1);
    int expiryDays = Days.daysBetween(periodDate.plusYears(1), new LocalDate()).getDays() - 1;
    FinancialYearJulyExpiryDayValidator yearlyExpiryDayValidator =
            new FinancialYearJulyExpiryDayValidator(
                    expiryDays,
                    periodDate.toString(PATTERN));
    assertFalse(yearlyExpiryDayValidator.canEdit());
}
 

/**
 * Follow the dayStep to re-format the time bucket literal long value.
 *
 * Such as, in dayStep == 11,
 *
 * 20000105 re-formatted time bucket is 20000101, 20000115 re-formatted time bucket is 20000112, 20000123
 * re-formatted time bucket is 20000123
 */
static long compressTimeBucket(long timeBucket, int dayStep) {
    if (dayStep > 1) {
        DateTime time = TIME_BUCKET_FORMATTER.parseDateTime("" + timeBucket);
        int days = Days.daysBetween(DAY_ONE, time).getDays();
        int groupBucketOffset = days % dayStep;
        return Long.parseLong(time.minusDays(groupBucketOffset).toString(TIME_BUCKET_FORMATTER));
    } else {
        /**
         * No calculation required. dayStep is for lower traffic. For normally configuration, there is pointless to calculate.
         */
        return timeBucket;
    }
}
 

@Override
   public NumberDataValue minus(DateTimeDataValue leftOperand, DateTimeDataValue rightOperand, NumberDataValue returnValue) throws StandardException {
	if( returnValue == null)
		returnValue = new SQLInteger();
	if(leftOperand.isNull() || rightOperand.isNull()) {
		returnValue.restoreToNull();
		return returnValue;
	}
	DateTime thatDate = rightOperand.getDateTime();
	Days diff = Days.daysBetween(thatDate, leftOperand.getDateTime());
	returnValue.setValue(diff.getDays());
	return returnValue;
}
 

@Test
public void days_between_two_dates_in_java_with_joda () {
	
	// start day is 1 day in the past
	DateTime startDate = new DateTime().minusDays(1);
	DateTime endDate = new DateTime();
	
	Days d = Days.daysBetween(startDate, endDate);
	int days = d.getDays();
	
	assertEquals(1, days);
}