Java Code Examples for org.joda.time.Interval#contains()

/**
 * Calculate the instants a snapshot should be retained for, given the
 * current time.
 */
public Set<DateTime> retentionTimes(DateTime now) {
    HashSet<DateTime> result = new HashSet<>();
    Interval interval = new Interval(now.minus(period), now);
    DateTime current = timeUnit.truncate(interval.getStart());
    while (current.isBefore(now)) {
        DateTime endOfUnit = current.plus(timeUnit.getPeriod());
        long step = new Interval(current, endOfUnit).toDurationMillis()
                / snapshotsPerTimeUnit;
        for (int i = 0; i < snapshotsPerTimeUnit; i++) {
            DateTime retentionTime = current.plus(i * step);
            if (interval.contains(retentionTime)) {
                result.add(retentionTime);
            }
        }
        current = endOfUnit;
    }
    return result;
}
 

public static Set<AcademicServiceRequest> getAcademicServiceRequests(Person person, Integer year,
        AcademicServiceRequestSituationType situation, Interval interval) {
    Set<AcademicServiceRequest> serviceRequests = new HashSet<AcademicServiceRequest>();
    Set<AcademicProgram> programs =
            AcademicAccessRule.getProgramsAccessibleToFunction(AcademicOperationType.SERVICE_REQUESTS, person.getUser())
                    .collect(Collectors.toSet());
    Collection<AcademicServiceRequest> possible = null;
    if (year != null) {
        possible = AcademicServiceRequestYear.getAcademicServiceRequests(year);
    } else {
        possible = Bennu.getInstance().getAcademicServiceRequestsSet();
    }
    for (AcademicServiceRequest request : possible) {
        if (!programs.contains(request.getAcademicProgram())) {
            continue;
        }
        if (situation != null && !request.getAcademicServiceRequestSituationType().equals(situation)) {
            continue;
        }
        if (interval != null && !interval.contains(request.getActiveSituationDate())) {
            continue;
        }
        serviceRequests.add(request);
    }
    return serviceRequests;
}
 

@Override
public List<OnlineWorkflowDetails> listWorkflows(Interval basecaseInterval) {
    LOGGER.info("Getting list of stored workflows run on basecases within the interval {}", basecaseInterval);
    String dateFormatPattern = "yyyyMMdd_HHmm";
    DateTimeFormatter formatter = DateTimeFormat.forPattern(dateFormatPattern);
    List<OnlineWorkflowDetails> workflowIds = new ArrayList<OnlineWorkflowDetails>();
    File[] files = config.getOnlineDbDir().toFile().listFiles(new FilenameFilter() {
        public boolean accept(File dir, String name) {
            return name.toLowerCase().startsWith(STORED_WORKFLOW_PREFIX);
        }
    });
    for (File file : files) {
        if (file.isFile()) {
            String workflowId = file.getName().substring(STORED_WORKFLOW_PREFIX.length());
            if (workflowId.length() > dateFormatPattern.length() && workflowId.substring(dateFormatPattern.length(), dateFormatPattern.length() + 1).equals("_")) {
                String basecaseName = workflowId.substring(0, dateFormatPattern.length() - 1);
                DateTime basecaseDate = DateTime.parse(basecaseName, formatter);
                if (basecaseInterval.contains(basecaseDate.getMillis())) {
                    OnlineWorkflowDetails workflowDetails = new OnlineWorkflowDetails(workflowId);
                    workflowDetails.setWorkflowDate(getWorkflowDate(workflowId));
                    workflowIds.add(workflowDetails);
                }
            }
        }
    }
    Collections.sort(workflowIds, new Comparator<OnlineWorkflowDetails>() {
        @Override
        public int compare(OnlineWorkflowDetails wfDetails1, OnlineWorkflowDetails wfDetails2) {
            return wfDetails1.getWorkflowDate().compareTo(wfDetails2.getWorkflowDate());
        }
    });
    LOGGER.info("Found {} workflow(s)", workflowIds.size());
    return workflowIds;
}
 

@Test
public void testInterval(){
	DateTime start = JodatimeUtils.parse("2016-11-24");
	DateTime end = JodatimeUtils.parse("2016-12-24");
	Interval interval = new Interval(start, end);
	boolean res = interval.contains(start.plusSeconds(1));
	Assertions.assertThat(res).isTrue();
	res = interval.contains(start.minusSeconds(1));
	Assertions.assertThat(res).isFalse();
}
 

private void checkEvaluationDate(final Date writtenEvaluationDate, final List<ExecutionCourse> executionCoursesToAssociate) {

        for (final ExecutionCourse executionCourse : executionCoursesToAssociate) {
            final long beginDate = executionCourse.getExecutionPeriod().getBeginDate().getTime();
            final long endDate = executionCourse.getExecutionPeriod().getEndDate().getTime();
            final DateTime endDateTime = new DateTime(endDate);
            final Interval interval = new Interval(beginDate, endDateTime.plusDays(1).getMillis());
            if (!interval.contains(writtenEvaluationDate.getTime())) {
                throw new DomainException("error.invalidWrittenTestDate");
            }
        }
    }
 

public Trade tradeAt(final DateTime date) {
    for (Trade trade : trades) {
        Interval interval = new Interval(trade.getOpen(), trade.getClose());
        if (interval.contains(date)) {
            return trade;
        }
    }

    return null;
}
 

/****
 * theTime是否在start和end的时间内
 * @param theTime
 * @param start
 * @param end
 * @return
 * @author way
 */
public static boolean isTimeBetweenInterval(Date theTime, Date start, Date end){
	Objects.requireNonNull(start);
	Objects.requireNonNull(end);
	Interval interval = createInterval(start, end);
	return interval.contains(new DateTime(theTime));
}