Example usage for org.joda.time Interval getStart

List of usage examples for org.joda.time Interval getStart

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. Interval
  6. getStart

Introduction

In this page you can find the example usage for org.joda.time Interval getStart.

Prototype

public DateTime getStart()

Source Link

Document

Gets the start of this time interval, which is inclusive, as a DateTime.

Usage

From source file:net.sourceforge.fenixedu.domain.personnelSection.contracts.PersonContractSituation.java

License:Open Source License

public int getDaysInInterval(Interval intervalWithNextPeriods) {
    LocalDate beginDate = getBeginDate().isBefore(intervalWithNextPeriods.getStart().toLocalDate())
            ? intervalWithNextPeriods.getStart().toLocalDate()
            : getBeginDate();/*from  w w w . j a v a2  s . c  o  m*/
    LocalDate endDate = getEndDate() == null
            || getEndDate().isAfter(intervalWithNextPeriods.getEnd().toLocalDate())
                    ? intervalWithNextPeriods.getEnd().toLocalDate()
                    : getEndDate();
    return Days.daysBetween(beginDate, endDate).getDays();
}

From source file:net.sourceforge.fenixedu.domain.personnelSection.contracts.PersonProfessionalRegime.java

License:Open Source License

public int getDaysInInterval(Interval interval) {
    LocalDate beginDate = getBeginDate().isBefore(interval.getStart().toLocalDate())
            ? interval.getStart().toLocalDate()
            : getBeginDate();//from www .  j a  v a 2s. c o m
    LocalDate endDate = getEndDate() == null || getEndDate().isAfter(interval.getEnd().toLocalDate())
            ? interval.getEnd().toLocalDate()
            : getEndDate();
    return Days.daysBetween(beginDate, endDate).getDays();
}

From source file:net.sourceforge.fenixedu.domain.space.EventSpaceOccupation.java

License:Open Source License

public boolean alreadyWasOccupiedBy(final EventSpaceOccupation occupation) {

    if (this.equals(occupation)) {
        return true;
    }//from w w  w .  j  a  v a2s. c  o m

    if (occupation.isLessonInstanceSpaceOccupation() || occupation.isWrittenEvaluationSpaceOccupation()
            || intersects(occupation.getBeginDate(), occupation.getEndDate())) {

        List<Interval> thisOccupationIntervals = getEventSpaceOccupationIntervals(occupation.getBeginDate(),
                occupation.getEndDate());
        List<Interval> passedOccupationIntervals = occupation
                .getEventSpaceOccupationIntervals((YearMonthDay) null, (YearMonthDay) null);

        for (Interval interval : thisOccupationIntervals) {
            for (Interval passedInterval : passedOccupationIntervals) {
                if (interval.getStart().isBefore(passedInterval.getEnd())
                        && interval.getEnd().isAfter(passedInterval.getStart())) {
                    return true;
                }
            }
        }
    }
    return false;
}

From source file:net.sourceforge.fenixedu.domain.space.EventSpaceOccupation.java

License:Open Source License

public boolean alreadyWasOccupiedIn(final YearMonthDay startDate, final YearMonthDay endDate,
        final HourMinuteSecond startTime, final HourMinuteSecond endTime, final DiaSemana dayOfWeek,
        final FrequencyType frequency, final Boolean dailyFrequencyMarkSaturday,
        final Boolean dailyFrequencyMarkSunday) {

    startTime.setSecondOfMinute(0);//from w w w.jav  a2 s  . c o m
    endTime.setSecondOfMinute(0);

    if (intersects(startDate, endDate)) {

        List<Interval> thisOccupationIntervals = getEventSpaceOccupationIntervals(startDate, endDate);
        List<Interval> passedOccupationIntervals = generateEventSpaceOccupationIntervals(startDate, endDate,
                startTime, endTime, frequency, dayOfWeek, dailyFrequencyMarkSaturday, dailyFrequencyMarkSunday,
                null, null);

        for (Interval interval : thisOccupationIntervals) {
            for (Interval passedInterval : passedOccupationIntervals) {
                if (interval.getStart().isBefore(passedInterval.getEnd())
                        && interval.getEnd().isAfter(passedInterval.getStart())) {
                    return true;
                }
            }
        }
    }
    return false;
}

From source file:net.sourceforge.fenixedu.domain.space.EventSpaceOccupation.java

License:Open Source License

public static List<Interval> generateEventSpaceOccupationIntervals(YearMonthDay begin, final YearMonthDay end,
        final HourMinuteSecond beginTime, final HourMinuteSecond endTime, final FrequencyType frequency,
        final DiaSemana diaSemana, final Boolean dailyFrequencyMarkSaturday,
        final Boolean dailyFrequencyMarkSunday, final YearMonthDay startDateToSearch,
        final YearMonthDay endDateToSearch) {

    List<Interval> result = new ArrayList<Interval>();
    begin = getBeginDateInSpecificWeekDay(diaSemana, begin);

    if (frequency == null) {
        if (!begin.isAfter(end) && (startDateToSearch == null
                || (!end.isBefore(startDateToSearch) && !begin.isAfter(endDateToSearch)))) {
            result.add(createNewInterval(begin, end, beginTime, endTime));
            return result;
        }//from w w  w.ja va  2 s.  co m
    } else {
        int numberOfDaysToSum = frequency.getNumberOfDays();
        while (true) {
            if (begin.isAfter(end)) {
                break;
            }
            if (startDateToSearch == null
                    || (!begin.isBefore(startDateToSearch) && !begin.isAfter(endDateToSearch))) {

                Interval interval = createNewInterval(begin, begin, beginTime, endTime);

                if (!frequency.equals(FrequencyType.DAILY) || ((dailyFrequencyMarkSaturday
                        || interval.getStart().getDayOfWeek() != SATURDAY_IN_JODA_TIME)
                        && (dailyFrequencyMarkSunday
                                || interval.getStart().getDayOfWeek() != SUNDAY_IN_JODA_TIME))) {

                    result.add(interval);
                }
            }
            begin = begin.plusDays(numberOfDaysToSum);
        }
    }
    return result;
}

From source file:net.sourceforge.fenixedu.domain.space.LessonSpaceOccupation.java

License:Open Source License

@Override
public boolean isOccupiedByExecutionCourse(final ExecutionCourse executionCourse, final DateTime start,
        final DateTime end) {
    final Lesson lesson = getLesson();
    if (lesson.getExecutionCourse() == executionCourse) {
        final List<Interval> intervals = getEventSpaceOccupationIntervals(start.toYearMonthDay(),
                end.toYearMonthDay().plusDays(1));
        for (final Interval interval : intervals) {
            if (start.isBefore(interval.getEnd()) && end.isAfter(interval.getStart())) {
                return true;
            }/*ww  w.j a va 2  s .c om*/
        }
    }
    return false;
}

From source file:net.sourceforge.fenixedu.domain.teacher.DegreeTeachingService.java

License:Open Source License

public double getTotalHoursAfter20AndSaturdays() {
    int minutesAfter20AndSaturday = 0;
    for (Lesson lesson : getShift().getAssociatedLessonsSet()) {
        for (Interval lessonInterval : lesson.getAllLessonIntervals()) {
            if (lessonInterval.getStart().getDayOfWeek() == DateTimeConstants.SATURDAY) {
                minutesAfter20AndSaturday += Minutes
                        .minutesBetween(lessonInterval.getStart(), lessonInterval.getEnd()).getMinutes();
            } else {
                DateTime dateTimeAfter20 = lessonInterval.getStart().toLocalDate()
                        .toDateTime(new LocalTime(20, 0, 0));
                if (dateTimeAfter20.isBefore(lessonInterval.getEnd())) {
                    if (!dateTimeAfter20.isAfter(lessonInterval.getStart())) {
                        minutesAfter20AndSaturday += Minutes
                                .minutesBetween(lessonInterval.getStart(), lessonInterval.getEnd())
                                .getMinutes();
                    } else {
                        minutesAfter20AndSaturday += Minutes
                                .minutesBetween(dateTimeAfter20, lessonInterval.getEnd()).getMinutes();
                    }// w  w w  .  j  a v  a 2  s.c om
                }

            }
        }
    }
    return (double) minutesAfter20AndSaturday / DateTimeConstants.MINUTES_PER_HOUR;
}

From source file:net.sourceforge.fenixedu.domain.Teacher.java

License:Open Source License

private List<Interval> getNotOverlapedIntervals(Interval overlapInterval, Interval notYetOverlapedInterval) {
    List<Interval> intervals = new ArrayList<Interval>();
    LocalDate overlapIntervalStart = overlapInterval.getStart().toLocalDate();
    LocalDate overlapIntervalEnd = overlapInterval.getEnd().toLocalDate();
    LocalDate notYetOverlapedIntervalStart = notYetOverlapedInterval.getStart().toLocalDate();
    LocalDate notYetOverlapedIntervalEnd = notYetOverlapedInterval.getEnd().toLocalDate();

    if (overlapIntervalStart.equals(notYetOverlapedIntervalStart)
            && !overlapIntervalEnd.equals(notYetOverlapedIntervalEnd)) {
        intervals.add(new Interval(overlapInterval.getEnd().plusDays(1), notYetOverlapedInterval.getEnd()));

    } else if (!overlapIntervalStart.equals(notYetOverlapedIntervalStart)
            && overlapIntervalEnd.equals(notYetOverlapedIntervalEnd)) {
        intervals/*from  w  ww  .  j a  va2s. c  o m*/
                .add(new Interval(notYetOverlapedInterval.getStart(), overlapInterval.getStart().minusDays(1)));

    } else if (!overlapIntervalStart.equals(notYetOverlapedIntervalStart)
            && !overlapIntervalEnd.equals(notYetOverlapedIntervalEnd)) {
        intervals
                .add(new Interval(notYetOverlapedInterval.getStart(), overlapInterval.getStart().minusDays(1)));
        intervals.add(new Interval(overlapInterval.getEnd().plusDays(1), notYetOverlapedInterval.getEnd()));
    }

    return intervals;
}

From source file:net.sourceforge.fenixedu.domain.Teacher.java

License:Open Source License

private boolean isSabbaticalForSemester(Interval exemptionInterval, Interval semesterPeriod) {
    double overlapPercentageThisSemester = calculateLessonsIntervalAndExemptionOverlapPercentage(semesterPeriod,
            exemptionInterval);//from www  . ja  v a  2s .  c  om
    if (overlapPercentageThisSemester == 1) {
        return true;
    }
    if (semesterPeriod.contains(exemptionInterval.getStart())) {
        return overlapPercentageThisSemester >= 0.5;
    }
    ExecutionSemester firstExecutionPeriod = ExecutionSemester.readByDateTime(exemptionInterval.getStart());
    Interval firstExecutionPeriodInterval = new Interval(
            firstExecutionPeriod.getBeginDateYearMonthDay().toLocalDate().toDateTimeAtStartOfDay(),
            firstExecutionPeriod.getEndDateYearMonthDay().toLocalDate().toDateTimeAtStartOfDay());
    double overlapPercentageFirstSemester = calculateLessonsIntervalAndExemptionOverlapPercentage(
            firstExecutionPeriodInterval, exemptionInterval);
    return overlapPercentageFirstSemester < 0.5;
}

From source file:net.sourceforge.fenixedu.domain.Teacher.java

License:Open Source License

public boolean isActiveForSemester(ExecutionSemester executionSemester) {
    int minimumWorkingDays = 90;
    int activeDays = 0;
    Interval semesterInterval = new Interval(
            executionSemester.getBeginDateYearMonthDay().toLocalDate().toDateTimeAtStartOfDay(),
            executionSemester.getEndDateYearMonthDay().toLocalDate().toDateTimeAtStartOfDay());
    PersonProfessionalData personProfessionalData = getPerson().getPersonProfessionalData();
    if (personProfessionalData != null) {
        GiafProfessionalData giafProfessionalData = personProfessionalData.getGiafProfessionalData();
        if (giafProfessionalData != null) {
            for (final PersonContractSituation situation : giafProfessionalData
                    .getValidPersonContractSituations()) {
                if (situation.overlaps(semesterInterval) && situation.getProfessionalCategory() != null
                        && situation.getProfessionalCategory().getCategoryType().equals(CategoryType.TEACHER)) {
                    LocalDate beginDate = situation.getBeginDate()
                            .isBefore(semesterInterval.getStart().toLocalDate())
                                    ? semesterInterval.getStart().toLocalDate()
                                    : situation.getBeginDate();
                    LocalDate endDate = situation.getEndDate() == null
                            || situation.getEndDate().isAfter(semesterInterval.getEnd().toLocalDate())
                                    ? semesterInterval.getEnd().toLocalDate()
                                    : situation.getEndDate();
                    int days = new Interval(beginDate.toDateTimeAtStartOfDay(),
                            endDate.toDateTimeAtStartOfDay()).toPeriod(PeriodType.days()).getDays() + 1;
                    activeDays = activeDays + days;
                }//w w  w.j  a  va  2  s . c om
            }
        }
    }
    return activeDays >= minimumWorkingDays;
}