List of usage examples for org.joda.time Interval overlaps
public boolean overlaps(ReadableInterval interval)
From source file:org.kuali.coeus.propdev.impl.budget.nonpersonnel.AddProjectBudgetLineItemHelper.java
License:Open Source License
protected List<AbstractBudgetRate> getInflationRates(List<AbstractBudgetRate> budgetRates, String rateTypeCode) {/* ww w . j a v a2 s.c o m*/ List<AbstractBudgetRate> inflationRates = new ArrayList<AbstractBudgetRate>(); for (AbstractBudgetRate budgetRate : budgetLineItem.getBudget().getBudgetRates()) { DateTime budgetRateStartDate = new DateTime(budgetRate.getStartDate().getTime()); DateTime budgetRateEndDate = budgetRateStartDate.plusYears(1).minusDays(1); Interval periodInterval = new Interval(budgetLineItem.getStartDate().getTime(), budgetLineItem.getEndDate().getTime()); Interval rateInterval = new Interval(budgetRateStartDate.getMillis(), budgetRateEndDate.getMillis()); if (StringUtils.equals(rateTypeCode, budgetRate.getRateTypeCode()) && StringUtils.equals(budgetRate.getRateClassType(), RateClassType.INFLATION.getRateClassType()) && budgetLineItem.getOnOffCampusFlag().equals(budgetRate.getOnOffCampusFlag()) && periodInterval.overlaps(rateInterval)) { inflationRates.add(budgetRate); } } return inflationRates; }
From source file:org.kuali.kpme.tklm.leave.calendar.validation.LeaveCalendarValidationUtil.java
License:Educational Community License
public static List<String> validateOverlap(Long startTime, Long endTime, String startDateS, String endTimeS, DateTime startTemp, DateTime endTemp, CalendarEntry calendarEntry, String lmLeaveBlockId, boolean isRegularEarnCode, String earnCodeType) { List<String> errors = new ArrayList<String>(); Interval addedTimeblockInterval = new Interval(startTime, endTime); List<Interval> dayInt = new ArrayList<Interval>(); String viewPrincipal = HrContext.getTargetPrincipalId(); dayInt.add(addedTimeblockInterval);//from w ww . j av a 2 s .co m List<Assignment> assignments = HrServiceLocator.getAssignmentService() .getAssignmentsByCalEntryForLeaveCalendar(viewPrincipal, calendarEntry); List<String> assignmentKeys = new ArrayList<String>(); for (Assignment assign : assignments) { assignmentKeys.add(assign.getAssignmentKey()); } List<LeaveBlock> leaveBlocks = LmServiceLocator.getLeaveBlockService().getLeaveBlocksForLeaveCalendar( viewPrincipal, calendarEntry.getBeginPeriodFullDateTime().toLocalDate(), calendarEntry.getEndPeriodFullDateTime().toLocalDate(), assignmentKeys); for (LeaveBlock leaveBlock : leaveBlocks) { if (errors.size() == 0 && StringUtils.equals(earnCodeType, HrConstants.EARN_CODE_TIME) && leaveBlock.getBeginTimestamp() != null && leaveBlock.getEndTimestamp() != null) { Interval leaveBlockInterval = new Interval(leaveBlock.getBeginTimestamp().getTime(), leaveBlock.getEndTimestamp().getTime()); for (Interval intv : dayInt) { if (isRegularEarnCode && leaveBlockInterval.overlaps(intv) && (lmLeaveBlockId == null || lmLeaveBlockId.compareTo(leaveBlock.getLmLeaveBlockId()) != 0)) { errors.add("The leave block you are trying to add overlaps with an existing time block."); } } } } return errors; }
From source file:org.kuali.kpme.tklm.time.clock.web.ClockAction.java
License:Educational Community License
public ActionForward validateNewTimeBlock(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) {//from w w w .ja v a 2s. c o m ClockActionForm caf = (ClockActionForm) form; String tbId = caf.getTbId(); String[] assignments = caf.getNewAssignDesCol().split(SEPERATOR); String[] beginDates = caf.getNewBDCol().split(SEPERATOR); String[] beginTimes = caf.getNewBTCol().split(SEPERATOR); String[] endDates = caf.getNewEDCol().split(SEPERATOR); String[] endTimes = caf.getNewETCol().split(SEPERATOR); String[] hrs = caf.getNewHrsCol().split(SEPERATOR); List<Interval> newIntervals = new ArrayList<Interval>(); JSONArray errorMsgList = new JSONArray(); // validates that all fields are available if (assignments.length != beginDates.length || assignments.length != beginTimes.length || assignments.length != endDates.length || assignments.length != endTimes.length || assignments.length != hrs.length) { errorMsgList.add("All fields are required"); caf.setOutputString(JSONValue.toJSONString(errorMsgList)); return mapping.findForward("ws"); } for (int i = 0; i < hrs.length; i++) { String index = String.valueOf(i + 1); // validate the hours field BigDecimal dc = new BigDecimal(hrs[i]); if (dc.compareTo(new BigDecimal("0")) == 0) { errorMsgList.add("The entered hours for entry " + index + " is not valid."); caf.setOutputString(JSONValue.toJSONString(errorMsgList)); return mapping.findForward("ws"); } // check if the begin / end time are valid // should not include time zone in consideration when conparing time intervals DateTime beginDateTime = TKUtils.convertDateStringToDateTimeWithoutZone(beginDates[i], beginTimes[i]); DateTime endDateTime = TKUtils.convertDateStringToDateTimeWithoutZone(endDates[i], endTimes[i]); if ((beginDateTime.compareTo(endDateTime) > 0 || endDateTime.compareTo(beginDateTime) < 0)) { errorMsgList.add("The time or date for entry " + index + " is not valid."); caf.setOutputString(JSONValue.toJSONString(errorMsgList)); return mapping.findForward("ws"); } // check if new time blocks overlap with existing time blocks Interval addedTimeblockInterval = new Interval(beginDateTime, endDateTime); newIntervals.add(addedTimeblockInterval); for (TimeBlock timeBlock : caf.getTimesheetDocument().getTimeBlocks()) { if (timeBlock.getTkTimeBlockId().equals(tbId)) { // ignore the original time block continue; } if (timeBlock.getHours().compareTo(BigDecimal.ZERO) == 0) { // ignore time blocks with zero hours continue; } DateTimeZone dateTimeZone = HrServiceLocator.getTimezoneService().getUserTimezoneWithFallback(); DateTime timeBlockBeginTimestamp = new DateTime(timeBlock.getBeginTimestamp().getTime(), dateTimeZone).withZone(TKUtils.getSystemDateTimeZone()); DateTime timeBlockEndTimestamp = new DateTime(timeBlock.getEndTimestamp().getTime(), dateTimeZone) .withZone(TKUtils.getSystemDateTimeZone()); Interval timeBlockInterval = new Interval(timeBlockBeginTimestamp, timeBlockEndTimestamp); if (timeBlockInterval.overlaps(addedTimeblockInterval)) { errorMsgList.add("The time block you are trying to add for entry " + index + " overlaps with an existing time block."); caf.setOutputString(JSONValue.toJSONString(errorMsgList)); return mapping.findForward("ws"); } } } // check if new time blocks overlap with each other if (newIntervals.size() > 1) { for (Interval intv1 : newIntervals) { for (Interval intv2 : newIntervals) { if (intv1.equals(intv2)) { continue; } if (intv1.overlaps(intv2)) { errorMsgList.add("There is time overlap between the entries."); caf.setOutputString(JSONValue.toJSONString(errorMsgList)); return mapping.findForward("ws"); } } } } caf.setOutputString(JSONValue.toJSONString(errorMsgList)); return mapping.findForward("ws"); }
From source file:org.kuali.kpme.tklm.time.detail.validation.TimeDetailValidationUtil.java
License:Educational Community License
public static List<String> validateOverlap(Long startTime, Long endTime, boolean acrossDays, String startDateS, String endTimeS, DateTime startTemp, DateTime endTemp, TimesheetDocument timesheetDocument, String timeblockId, boolean isRegularEarnCode) { List<String> errors = new ArrayList<String>(); Interval addedTimeblockInterval = new Interval(startTime, endTime); List<Interval> dayInt = new ArrayList<Interval>(); //if the user is clocked in, check if this time block overlaps with the clock action ClockLog lastClockLog = TkServiceLocator.getClockLogService() .getLastClockLog(HrContext.getTargetPrincipalId()); if (lastClockLog != null && (lastClockLog.getClockAction().equals(TkConstants.CLOCK_IN) || lastClockLog.getClockAction().equals(TkConstants.LUNCH_IN))) { DateTime lastClockDateTime = lastClockLog.getClockDateTime(); String lastClockZone = lastClockLog.getClockTimestampTimezone(); if (StringUtils.isEmpty(lastClockZone)) { lastClockZone = TKUtils.getSystemTimeZone(); }//from ww w. ja v a2 s . c o m DateTimeZone zone = DateTimeZone.forID(lastClockZone); DateTime clockWithZone = lastClockDateTime.withZone(zone); DateTime currentTime = new DateTime(System.currentTimeMillis(), zone); Interval currentClockInInterval = new Interval(clockWithZone.getMillis(), currentTime.getMillis()); if (isRegularEarnCode && addedTimeblockInterval.overlaps(currentClockInInterval)) { errors.add("The time block you are trying to add overlaps with the current clock action."); return errors; } } if (acrossDays) { DateTime start = new DateTime(startTime); DateTime end = TKUtils.convertDateStringToDateTime(startDateS, endTimeS); if (endTemp.getDayOfYear() - startTemp.getDayOfYear() < 1) { end = new DateTime(endTime); } DateTime groupEnd = new DateTime(endTime); Long startLong = start.getMillis(); Long endLong = end.getMillis(); //create interval span if start is before the end and the end is after the start except //for when the end is midnight ..that converts to midnight of next day DateMidnight midNight = new DateMidnight(endLong); while (start.isBefore(groupEnd.getMillis()) && ((endLong >= startLong) || end.isEqual(midNight))) { Interval tempInt = null; if (end.isEqual(midNight)) { tempInt = addedTimeblockInterval; } else { tempInt = new Interval(startLong, endLong); } dayInt.add(tempInt); start = start.plusDays(1); end = end.plusDays(1); startLong = start.getMillis(); endLong = end.getMillis(); } } else { dayInt.add(addedTimeblockInterval); } for (TimeBlock timeBlock : timesheetDocument.getTimeBlocks()) { if (errors.size() == 0 && StringUtils.equals(timeBlock.getEarnCodeType(), HrConstants.EARN_CODE_TIME)) { Interval timeBlockInterval = new Interval(timeBlock.getBeginTimestamp().getTime(), timeBlock.getEndTimestamp().getTime()); for (Interval intv : dayInt) { if (isRegularEarnCode && timeBlockInterval.overlaps(intv) && (timeblockId == null || timeblockId.compareTo(timeBlock.getTkTimeBlockId()) != 0)) { errors.add("The time block you are trying to add overlaps with an existing time block."); } } } } return errors; }
From source file:org.kuali.kpme.tklm.time.rules.shiftdifferential.service.ShiftDifferentialRuleServiceImpl.java
License:Educational Community License
@Override public void processShiftDifferentialRules(TimesheetDocument timesheetDocument, TkTimeBlockAggregate aggregate) { DateTimeZone zone = HrServiceLocator.getTimezoneService().getUserTimezoneWithFallback(); List<List<TimeBlock>> blockDays = aggregate.getDayTimeBlockList(); DateTime periodStartDateTime = timesheetDocument.getCalendarEntry().getBeginPeriodLocalDateTime() .toDateTime(zone);// w w w . j a v a2s .c o m Map<Long, Set<ShiftDifferentialRule>> jobNumberToShifts = getJobNumberToShiftRuleMap(timesheetDocument); // If there are no shift differential rules, we have an early exit. if (jobNumberToShifts.isEmpty()) { return; } // Get the last day of the previous pay period. We need this to determine // if there are hours from the previous pay period that will effect the // shift rule on the first day of the currently-being-processed pay period. // // Will be set to null if not applicable. boolean previousPayPeriodPrevDay = true; Map<Long, List<TimeBlock>> jobNumberToTimeBlocksPreviousDay = getPreviousPayPeriodLastDayJobToTimeBlockMap( timesheetDocument, jobNumberToShifts); // We are going to look at the time blocks grouped by Days. // // This is a very large outer loop. for (int pos = 0; pos < blockDays.size(); pos++) { List<TimeBlock> blocks = blockDays.get(pos); // Timeblocks for this day. if (blocks.isEmpty()) continue; // No Time blocks, no worries. DateTime currentDay = periodStartDateTime.plusDays(pos); Interval virtualDay = new Interval(currentDay, currentDay.plusHours(24)); // Builds our JobNumber to TimeBlock for Current Day List. // // Shift Differential Rules are also grouped by Job number, this // provides a quick way to do the lookup / reference. // We don't need every time block, only the ones that will be // applicable to the shift rules. Map<Long, List<TimeBlock>> jobNumberToTimeBlocks = new HashMap<Long, List<TimeBlock>>(); for (TimeBlock block : blocks) { Long jobNumber = block.getJobNumber(); if (jobNumberToShifts.containsKey(jobNumber)) { List<TimeBlock> jblist = jobNumberToTimeBlocks.get(jobNumber); if (jblist == null) { jblist = new ArrayList<TimeBlock>(); jobNumberToTimeBlocks.put(jobNumber, jblist); } jblist.add(block); } } // Large Outer Loop to look at applying the Shift Rules based on // the current JobNumber. // // This loop will handle previous day boundary time as well as the // current day. // // There is room for refactoring here! for (Map.Entry<Long, Set<ShiftDifferentialRule>> entry : jobNumberToShifts.entrySet()) { Set<ShiftDifferentialRule> shiftDifferentialRules = entry.getValue(); // Obtain and sort our previous and current time blocks. List<TimeBlock> ruleTimeBlocksPrev = null; List<TimeBlock> ruleTimeBlocksCurr = jobNumberToTimeBlocks.get(entry.getKey()); if (ruleTimeBlocksCurr != null && ruleTimeBlocksCurr.size() > 0) { if (jobNumberToTimeBlocksPreviousDay != null) ruleTimeBlocksPrev = jobNumberToTimeBlocksPreviousDay.get(entry.getKey()); if (ruleTimeBlocksPrev != null && ruleTimeBlocksPrev.size() > 0) this.sortTimeBlocksInverse(ruleTimeBlocksPrev); this.sortTimeBlocksNatural(ruleTimeBlocksCurr); } else { // Skip to next job, there is nothing for this job // on this day, and because of this we don't care // about the previous day either. continue; } for (ShiftDifferentialRule rule : shiftDifferentialRules) { Set<String> fromEarnGroup = HrServiceLocator.getEarnCodeGroupService() .getEarnCodeListForEarnCodeGroup(rule.getFromEarnGroup(), timesheetDocument .getCalendarEntry().getBeginPeriodFullDateTime().toLocalDate()); LocalTime ruleStart = new LocalTime(rule.getBeginTime(), zone); LocalTime ruleEnd = new LocalTime(rule.getEndTime(), zone); DateTime shiftEnd = ruleEnd.toDateTime(currentDay); DateTime shiftStart = ruleStart.toDateTime(currentDay); if (shiftEnd.isBefore(shiftStart) || shiftEnd.isEqual(shiftStart)) { shiftEnd = shiftEnd.plusDays(1); } Interval shiftInterval = new Interval(shiftStart, shiftEnd); // Set up buckets to handle previous days time accumulations BigDecimal hoursBeforeVirtualDay = BigDecimal.ZERO; // Check current day first block to see if start time gap from virtual day start is greater than max gap // if so, we can skip the previous day checks. TimeBlock firstBlockOfCurrentDay = null; for (TimeBlock b : ruleTimeBlocksCurr) { if (timeBlockHasEarnCode(fromEarnGroup, b)) { firstBlockOfCurrentDay = b; break; } } // Previous Day :: We have prior block container of nonzero size, and the previous day is active. Interval previousDayShiftInterval = new Interval(shiftStart.minusDays(1), shiftEnd.minusDays(1)); // Blank initialization pointer for picking which interval to pass to applyPremium() Interval evalInterval = null; if (ruleTimeBlocksPrev != null && ruleTimeBlocksPrev.size() > 0 && dayIsRuleActive(currentDay.minusDays(1), rule)) { // Simple heuristic to see if we even need to worry about // the Shift rule for this set of data. if (shiftEnd.isAfter(virtualDay.getEnd())) { // Compare first block of previous day with first block of current day for max gaptitude. TimeBlock firstBlockOfPreviousDay = null; for (TimeBlock b : ruleTimeBlocksPrev) { if (timeBlockHasEarnCode(fromEarnGroup, b)) { firstBlockOfPreviousDay = b; break; } } // Only if we actually have at least one block. // Adding Assumption: We must have both a valid current and previous block. Max Gap can not be more than a virtual day. // If this assumption does not hold, additional logic will be needed to iteratively go back in time to figure out which // blocks are valid. if ((firstBlockOfPreviousDay != null) && (firstBlockOfCurrentDay != null)) { Interval previousBlockInterval = new Interval( firstBlockOfPreviousDay.getEndDateTime().withZone(zone), firstBlockOfCurrentDay.getBeginDateTime().withZone(zone)); Duration blockGapDuration = previousBlockInterval.toDuration(); BigDecimal bgdHours = TKUtils.convertMillisToHours(blockGapDuration.getMillis()); // if maxGap is 0, ignore gaps and assign shift to time blocks within the hours if (rule.getMaxGap().compareTo(BigDecimal.ZERO) == 0 || bgdHours.compareTo(rule.getMaxGap()) <= 0) { // If we are here, we know we have at least one valid time block to pull some hours forward from. // These are inversely sorted. for (int i = 0; i < ruleTimeBlocksPrev.size(); i++) { TimeBlock b = ruleTimeBlocksPrev.get(i); if (timeBlockHasEarnCode(fromEarnGroup, b)) { Interval blockInterval = new Interval( b.getBeginDateTime().withZone(zone), b.getEndDateTime().withZone(zone)); // Calculate Block Gap, the duration between clock outs and clock ins of adjacent time blocks. if (previousBlockInterval != null) { blockGapDuration = new Duration(b.getEndDateTime().withZone(zone), previousBlockInterval.getStart()); bgdHours = TKUtils .convertMillisToHours(blockGapDuration.getMillis()); } // Check Gap, if good, sum hours, if maxGap is 0, ignore gaps if (rule.getMaxGap().compareTo(BigDecimal.ZERO) == 0 || bgdHours.compareTo(rule.getMaxGap()) <= 0) { // Calculate Overlap and add it to hours before virtual day bucket. if (blockInterval.overlaps(previousDayShiftInterval)) { BigDecimal hrs = TKUtils.convertMillisToHours(blockInterval .overlap(previousDayShiftInterval).toDurationMillis()); hoursBeforeVirtualDay = hoursBeforeVirtualDay.add(hrs); } } else { // Time blocks are reverse sorted, we can jump out as soon as the max gap is exceeded. break; } previousBlockInterval = blockInterval; } } } else { // DO NOTHING! } } } } BigDecimal hoursToApply = BigDecimal.ZERO; BigDecimal hoursToApplyPrevious = BigDecimal.ZERO; // If the hours before virtual day are less than or equal to // min hours, we have already applied the time, so we don't // set hoursToApplyPrevious if (hoursBeforeVirtualDay.compareTo(rule.getMinHours()) <= 0) { // we need to apply these hours. hoursToApplyPrevious = hoursBeforeVirtualDay; } // Current Day TimeBlock previous = null; // Previous Time Block List<TimeBlock> accumulatedBlocks = new ArrayList<TimeBlock>(); // TimeBlocks we MAY or MAY NOT apply Shift Premium to. List<Interval> accumulatedBlockIntervals = new ArrayList<Interval>(); // To save recompute time when checking timeblocks for application we store them as we create them. // Iterate over sorted list, checking time boundaries vs Shift Intervals. long accumulatedMillis = TKUtils.convertHoursToMillis(hoursBeforeVirtualDay); boolean previousDayOnly = false; // IF the rule is not active today, but was on the previous day, we need to still look at time blocks. if (!dayIsRuleActive(currentDay, rule)) { if (dayIsRuleActive(currentDay.minusDays(1), rule)) { previousDayOnly = true; } else { // Nothing to see here, move to next rule. continue; } } /* * We will touch each time block and accumulate time blocks that are applicable to * the current rule we are on. */ // These blocks are only used for detail application // We don't want to pass along the previous pay period, // because we don't want to modify the time blocks on that // period. If null is passed, time will be placed on the // first block of the first period if the previous period // block had influence. List<TimeBlock> previousBlocksFiltered = (previousPayPeriodPrevDay) ? null : filterBlocksByApplicableEarnGroup(fromEarnGroup, ruleTimeBlocksPrev); for (TimeBlock current : ruleTimeBlocksCurr) { if (!timeBlockHasEarnCode(fromEarnGroup, current)) { // TODO: WorkSchedule considerations somewhere in here? continue; } Interval blockInterval = new Interval(current.getBeginDateTime().withZone(zone), current.getEndDateTime().withZone(zone)); // Check both Intervals, since the time blocks could still // be applicable to the previous day. These two intervals should // not have any overlap. if (previousDayShiftInterval.overlaps(shiftInterval)) { LOG.error("Interval of greater than 24 hours created in the rules processing."); return; // throw new RuntimeException("Interval of greater than 24 hours created in the rules processing."); } // This block of code handles cases where you have time // that spills to multiple days and a shift rule that // has a valid window on multiple consecutive days. Time // must be applied with the correct shift interval. Interval overlap = previousDayShiftInterval.overlap(blockInterval); evalInterval = previousDayShiftInterval; if (overlap == null) { if (hoursToApplyPrevious.compareTo(BigDecimal.ZERO) > 0) { // we have hours from previous day, and the shift // window is going to move to current day. // Need to apply this now, and move window forward // for current time block. BigDecimal accumHours = TKUtils.convertMillisToHours(accumulatedMillis); this.applyAccumulatedWrapper(accumHours, evalInterval, accumulatedBlockIntervals, accumulatedBlocks, previousBlocksFiltered, hoursToApplyPrevious, hoursToApply, rule); accumulatedMillis = 0L; // reset accumulated hours.. hoursToApply = BigDecimal.ZERO; hoursToApplyPrevious = BigDecimal.ZERO; } // Because of our position in the loop, when we are at this point, // we know we've passed any previous day shift intervals, so we can // determine if we should skip the current day based on the boolean // we set earlier. if (previousDayOnly) { continue; } overlap = shiftInterval.overlap(blockInterval); evalInterval = shiftInterval; } // Time bucketing and application as normal: // if (overlap != null) { // There IS overlap. if (previous != null) { // only check max gap if max gap of rule is not 0 if (rule.getMaxGap().compareTo(BigDecimal.ZERO) != 0 && exceedsMaxGap(previous, current, rule.getMaxGap())) { BigDecimal accumHours = TKUtils.convertMillisToHours(accumulatedMillis); this.applyAccumulatedWrapper(accumHours, evalInterval, accumulatedBlockIntervals, accumulatedBlocks, previousBlocksFiltered, hoursToApplyPrevious, hoursToApply, rule); accumulatedMillis = 0L; // reset accumulated hours.. hoursToApply = BigDecimal.ZERO; hoursToApplyPrevious = BigDecimal.ZERO; } else { long millis = overlap.toDurationMillis(); accumulatedMillis += millis; hoursToApply = hoursToApply.add(TKUtils.convertMillisToHours(millis)); } } else { // Overlap shift at first time block. long millis = overlap.toDurationMillis(); accumulatedMillis += millis; hoursToApply = hoursToApply.add(TKUtils.convertMillisToHours(millis)); } accumulatedBlocks.add(current); accumulatedBlockIntervals.add(blockInterval); previous = current; // current can still apply to next. } else { // No Overlap / Outside of Rule if (previous != null) { BigDecimal accumHours = TKUtils.convertMillisToHours(accumulatedMillis); this.applyAccumulatedWrapper(accumHours, evalInterval, accumulatedBlockIntervals, accumulatedBlocks, previousBlocksFiltered, hoursToApplyPrevious, hoursToApply, rule); accumulatedMillis = 0L; // reset accumulated hours.. hoursToApply = BigDecimal.ZERO; hoursToApplyPrevious = BigDecimal.ZERO; } } } // All time blocks are iterated over, check for remainders. // Check containers for time, and apply if needed. BigDecimal accumHours = TKUtils.convertMillisToHours(accumulatedMillis); this.applyAccumulatedWrapper(accumHours, evalInterval, accumulatedBlockIntervals, accumulatedBlocks, previousBlocksFiltered, hoursToApplyPrevious, hoursToApply, rule); } } // Keep track of previous as we move day by day. jobNumberToTimeBlocksPreviousDay = jobNumberToTimeBlocks; previousPayPeriodPrevDay = false; } }
From source file:org.kuali.kpme.tklm.time.rules.shiftdifferential.shift.ShiftCalendarInterval.java
License:Educational Community License
protected List<Shift> createShifts(ShiftDifferentialRule rule, LocalDateTime spanBegin, LocalDateTime spanEnd, DateTimeZone zone) {/*from ww w . j av a2 s . c o m*/ DateTime spanBeginDT = spanBegin.toDateTime(zone); DateTime spanEndDT = spanEnd.toDateTime(zone); Interval calendarEntryInterval = new Interval(spanBeginDT, spanEndDT); DateTime shiftEnd = LocalTime.fromDateFields(rule.getEndTime()).toDateTime(spanBeginDT).minusDays(1); DateTime shiftStart = LocalTime.fromDateFields(rule.getBeginTime()).toDateTime(spanBeginDT).minusDays(1); if (shiftEnd.isBefore(shiftStart) || shiftEnd.isEqual(shiftStart)) { shiftEnd = shiftEnd.plusDays(1); } List<Shift> shifts = new ArrayList<Shift>(); Interval shiftInterval = new Interval(shiftStart, shiftEnd); //possible that there is no overlap between 1st interval and cal entry interval... if so, add a day. if (!calendarEntryInterval.overlaps(shiftInterval)) { shiftInterval = incrementShift(shiftInterval); } while (calendarEntryInterval.overlaps(shiftInterval)) { if (ruleIsActiveForDay(shiftInterval.getStart(), rule)) { shifts.add(new Shift(rule, shiftInterval, zone)); } shiftInterval = incrementShift(shiftInterval); } return shifts; }
From source file:org.libreplan.business.calendars.entities.AvailabilityTimeLine.java
License:Open Source License
private List<Interval> intersectWithAdjacent(Interval interval) { List<Interval> result = new ArrayList<>(); List<Interval> adjacent = getAdjacent(interval); for (Interval each : adjacent) { assert interval.overlaps(each); result.add(interval.intersect(each)); }//from w w w .j ava 2 s. c o m return result; }
From source file:org.libreplan.business.calendars.entities.AvailabilityTimeLine.java
License:Open Source License
private void removeAdjacent(int insertionPoint, Interval inserted) { ListIterator<Interval> listIterator = invalids.listIterator(insertionPoint + 1); while (listIterator.hasNext()) { Interval next = listIterator.next(); if (!next.overlaps(inserted)) { break; }/*from ww w . j a v a 2s. co m*/ listIterator.remove(); } }
From source file:org.libreplan.business.calendars.entities.CalendarAvailability.java
License:Open Source License
public boolean isActiveBetween(LocalDate filterStartDate, LocalDate filterEndDate) { if (filterStartDate == null && filterEndDate == null) { return true; }/* ww w . j av a 2 s . c om*/ if (filterStartDate == null) { if (endDate == null) { return startDate.compareTo(filterEndDate) <= 0; } return startDate.compareTo(filterEndDate) <= 0 || endDate.compareTo(filterEndDate) <= 0; } if (filterEndDate == null) { return endDate == null || startDate.compareTo(filterStartDate) >= 0 || endDate.compareTo(filterStartDate) >= 0; } if (endDate == null) { return startDate.compareTo(filterStartDate) <= 0 || startDate.compareTo(filterEndDate) <= 0; } Interval filterPeriod = new Interval(filterStartDate.toDateTimeAtStartOfDay(), filterEndDate.plusDays(1).toDateTimeAtStartOfDay()); Interval activationPeriod = new Interval(startDate.toDateTimeAtStartOfDay(), endDate.plusDays(1).toDateTimeAtStartOfDay()); return filterPeriod.overlaps(activationPeriod); }
From source file:org.libreplan.business.planner.entities.SpecificResourceAllocation.java
License:Open Source License
private List<Interval> getIntervalsRelatedWith(Criterion criterion, LocalDate startInclusive, LocalDate endExclusive) { Interval queryInterval = AvailabilityTimeLine.Interval.create(startInclusive, endExclusive); List<Interval> result = new ArrayList<>(); for (Interval each : getIntervalsThisAllocationInterferesWith(criterion)) { if (queryInterval.overlaps(each)) { result.add(queryInterval.intersect(each)); }/*from w w w .j a v a2 s. co m*/ } return result; }