List of usage examples for org.joda.time Interval getStart
public DateTime getStart()
From source file:org.kuali.kpme.tklm.leave.block.LeaveBlockAggregate.java
License:Educational Community License
/** * build leaveBlockAggregate with given leaveBlocks, calendarEntry and dayIntervals * dayIntervals with full week span is for Time Calendar * @param LeaveBlocks/*from w ww.j a va2 s .c om*/ * @param leaveCalendarEntry * @param dayIntervals */ public LeaveBlockAggregate(List<LeaveBlock> leaveBlocks, CalendarEntry leaveCalendarEntry, List<Interval> dayIntervals) { this.leaveCalendarEntry = leaveCalendarEntry; for (Interval dayInt : dayIntervals) { List<LeaveBlock> dayLeaveBlocks = new ArrayList<LeaveBlock>(); DateTime localTime = dayInt.getStart().toLocalDateTime().toDateTime(); String intervalStartDateString = localTime.toLocalDate().toString(); for (LeaveBlock leaveBlock : leaveBlocks) { // if the interval end time is 0, ie the beginning of a day, use the date string of the interval start time // to check if the leave block should go into this interval. Leave blocks only have leaveDate, there's no leave time if (dayInt.getEnd().getHourOfDay() == 0) { String lbDateString = leaveBlock.getLeaveLocalDate().toString(); if (intervalStartDateString.equals(lbDateString)) { dayLeaveBlocks.add(leaveBlock); } } else { LocalDate localDate = leaveBlock.getLeaveLocalDate(); LocalDate dayIntBegin = dayInt.getStart().toLocalDate(); if (localDate.equals(dayIntBegin)) { dayLeaveBlocks.add(leaveBlock); } } } dayLeaveBlockList.add(dayLeaveBlocks); } }
From source file:org.kuali.kpme.tklm.leave.block.service.LeaveBlockServiceImpl.java
License:Educational Community License
@Override public void addLeaveBlocks(DateTime beginDate, DateTime endDate, CalendarEntry ce, String selectedEarnCode, BigDecimal hours, String description, Assignment selectedAssignment, String spanningWeeks, String leaveBlockType, String principalId) { DateTimeZone timezone = HrServiceLocator.getTimezoneService().getUserTimezoneWithFallback(); DateTime calBeginDateTime = beginDate; DateTime calEndDateTime = endDate;/*from w ww .j ava 2s .co m*/ if (ce != null) { calBeginDateTime = ce.getBeginPeriodLocalDateTime().toDateTime(); calEndDateTime = ce.getEndPeriodLocalDateTime().toDateTime(); } else { LOG.error("Calendar Entry parameter is null."); return; // throw new RuntimeException("Calendar Entry parameter is null."); } Interval calendarInterval = new Interval(calBeginDateTime, calEndDateTime); // To create the correct interval by the given begin and end dates, // we need to plus one day on the end date to include that date List<Interval> leaveBlockIntervals = TKUtils.createDaySpan(beginDate.toLocalDate().toDateTimeAtStartOfDay(), endDate.toLocalDate().toDateTimeAtStartOfDay().plusDays(1), TKUtils.getSystemDateTimeZone()); // need to use beginDate and endDate of the calendar to find all leaveBlocks since LeaveCalendarDocument Id is not always available List<LeaveBlock> currentLeaveBlocks = getLeaveBlocks(principalId, calBeginDateTime.toLocalDate(), calEndDateTime.toLocalDate()); // use the current calendar's begin and end date to figure out if this pay period has a leaveDocument LeaveCalendarDocumentHeader lcdh = LmServiceLocator.getLeaveCalendarDocumentHeaderService() .getDocumentHeader(principalId, ce.getBeginPeriodLocalDateTime().toDateTime(), ce.getEndPeriodLocalDateTime().toDateTime()); String docId = lcdh == null ? null : lcdh.getDocumentId(); // TODO: need to integrate with the scheduled timeoff. Interval firstDay = null; DateTime currentDate = beginDate; for (Interval leaveBlockInt : leaveBlockIntervals) { if (calendarInterval.contains(leaveBlockInt)) { // KPME-1446 if "Include weekends" check box is checked, don't add Sat and Sun to the leaveblock list if (StringUtils.isEmpty(spanningWeeks) && (leaveBlockInt.getStart().getDayOfWeek() == DateTimeConstants.SATURDAY || leaveBlockInt.getStart().getDayOfWeek() == DateTimeConstants.SUNDAY)) { // do nothing } else { // Currently, we store the accrual category value in the leave code table, but store accrual category id in the leaveBlock. // That's why there is a two step server call to get the id. This might be changed in the future. CalendarEntry calendarEntry = HrServiceLocator.getCalendarEntryService() .getCurrentCalendarEntryByCalendarId(ce.getHrCalendarId(), new LocalDate().toDateTimeAtStartOfDay()); DateTime leaveBlockDate = leaveBlockInt.getStart(); String requestStatus = HrConstants.REQUEST_STATUS.USAGE; if (LmServiceLocator.getLeaveApprovalService().isActiveAssignmentFoundOnJobFlsaStatus( principalId, HrConstants.FLSA_STATUS_NON_EXEMPT, true)) { TimesheetDocumentHeader tdh = TkServiceLocator.getTimesheetDocumentHeaderService() .getDocumentHeaderForDate(principalId, leaveBlockDate); if (tdh != null) { if (DateUtils.isSameDay(leaveBlockDate.toDate(), tdh.getEndDate()) || leaveBlockDate.isAfter(tdh.getEndDateTime())) { requestStatus = HrConstants.REQUEST_STATUS.PLANNED; } } else { requestStatus = HrConstants.REQUEST_STATUS.PLANNED; } } else { if (DateUtils.isSameDay(leaveBlockDate.toDate(), calendarEntry.getEndPeriodDateTime()) || leaveBlockDate.isAfter(calendarEntry.getEndPeriodFullDateTime())) { requestStatus = HrConstants.REQUEST_STATUS.PLANNED; } } EarnCode earnCodeObj = HrServiceLocator.getEarnCodeService().getEarnCode(selectedEarnCode, ce.getEndPeriodLocalDateTime().toDateTime().toLocalDate()); if (earnCodeObj != null && earnCodeObj.getRecordMethod().equals(HrConstants.RECORD_METHOD.TIME)) { if (firstDay != null) { if (!leaveBlockInt.contains(endDate)) { currentDate = leaveBlockInt.getStart(); } else if ((leaveBlockInt.getStartMillis() - endDate.getMillis()) != 0) { hours = TKUtils.getHoursBetween(leaveBlockInt.getStartMillis(), endDate.getMillis()); hours = negateHoursIfNecessary(leaveBlockType, hours); LeaveBlock leaveBlock = buildLeaveBlock(leaveBlockInt.getStart().toLocalDate(), docId, principalId, selectedEarnCode, hours, description, earnCodeObj.getAccrualCategory(), selectedAssignment, requestStatus, leaveBlockType, leaveBlockInt.getStart(), endDate); if (!currentLeaveBlocks.contains(leaveBlock)) { currentLeaveBlocks.add(leaveBlock); } break; } } if (leaveBlockInt.contains(currentDate)) { firstDay = leaveBlockInt; if (leaveBlockInt.contains(endDate) || (endDate.getMillis() == leaveBlockInt.getEnd().getMillis())) { hours = TKUtils.getHoursBetween(currentDate.getMillis(), endDate.getMillis()); hours = negateHoursIfNecessary(leaveBlockType, hours); LeaveBlock leaveBlock = buildLeaveBlock(leaveBlockInt.getStart().toLocalDate(), docId, principalId, selectedEarnCode, hours, description, earnCodeObj.getAccrualCategory(), selectedAssignment, requestStatus, leaveBlockType, currentDate, endDate); if (!currentLeaveBlocks.contains(leaveBlock)) { currentLeaveBlocks.add(leaveBlock); } break; } else { // create a leave block that wraps the 24 hr day hours = TKUtils.getHoursBetween(currentDate.getMillis(), firstDay.getEndMillis()); hours = negateHoursIfNecessary(leaveBlockType, hours); LeaveBlock leaveBlock = buildLeaveBlock(leaveBlockInt.getStart().toLocalDate(), docId, principalId, selectedEarnCode, hours, description, earnCodeObj.getAccrualCategory(), selectedAssignment, requestStatus, leaveBlockType, currentDate, firstDay.getEnd()); if (!currentLeaveBlocks.contains(leaveBlock)) { currentLeaveBlocks.add(leaveBlock); } } } } else { hours = negateHoursIfNecessary(leaveBlockType, hours); LeaveBlock leaveBlock = buildLeaveBlock(leaveBlockInt.getStart().toLocalDate(), docId, principalId, selectedEarnCode, hours, description, earnCodeObj.getAccrualCategory(), selectedAssignment, requestStatus, leaveBlockType, null, null); if (!currentLeaveBlocks.contains(leaveBlock)) { currentLeaveBlocks.add(leaveBlock); } } } } } saveLeaveBlocks(currentLeaveBlocks); }
From source file:org.kuali.kpme.tklm.leave.summary.service.LeaveSummaryServiceImpl.java
License:Educational Community License
@Override public List<Date> getLeaveSummaryDates(CalendarEntry calendarEntry) { List<Date> leaveSummaryDates = new ArrayList<Date>(); DateTime start = calendarEntry.getBeginPeriodLocalDateTime().toDateTime(); DateTime end = calendarEntry.getEndPeriodLocalDateTime().toDateTime(); Interval interval = new Interval(start, end); for (DateTime day = interval.getStart(); day.isBefore(interval.getEnd()); day = day.plusDays(1)) { leaveSummaryDates.add(day.toLocalDate().toDateTimeAtStartOfDay().toDate()); }//from www.j ava2 s . c o m return leaveSummaryDates; }
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);/*from w w w . j a va2 s . c om*/ 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) {/* w ww . j a va 2 s.co 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.kuali.kpme.tklm.time.rules.shiftdifferential.shift.ShiftCalendarInterval.java
License:Educational Community License
protected Interval incrementShift(Interval current) { return new Interval(current.getStart().plusDays(1), current.getEnd().plusDays(1)); }
From source file:org.kuali.kpme.tklm.time.timeblock.service.TimeBlockServiceImpl.java
License:Educational Community License
public List<TimeBlock> buildTimeBlocksSpanDates(Assignment assignment, String earnCode, TimesheetDocument timesheetDocument, DateTime beginDateTime, DateTime endDateTime, BigDecimal hours, BigDecimal amount, Boolean getClockLogCreated, Boolean getLunchDeleted, String spanningWeeks, String userPrincipalId) { DateTimeZone zone = HrServiceLocator.getTimezoneService().getUserTimezoneWithFallback(); DateTime beginDt = beginDateTime.withZone(zone); DateTime endDt = beginDt.toLocalDate().toDateTime(endDateTime.withZone(zone).toLocalTime(), zone); if (endDt.isBefore(beginDt)) endDt = endDt.plusDays(1);// ww w . j a va 2 s . c o m List<Interval> dayInt = TKUtils.getDaySpanForCalendarEntry(timesheetDocument.getCalendarEntry()); TimeBlock firstTimeBlock = new TimeBlock(); List<TimeBlock> lstTimeBlocks = new ArrayList<TimeBlock>(); DateTime endOfFirstDay = null; // KPME-2568 long diffInMillis = 0; // KPME-2568 for (Interval dayIn : dayInt) { if (dayIn.contains(beginDt)) { if (dayIn.contains(endDt) || dayIn.getEnd().equals(endDt)) { // KPME-1446 if "Include weekends" check box is checked, don't add Sat and Sun to the timeblock list if (StringUtils.isEmpty(spanningWeeks) && (dayIn.getStart().getDayOfWeek() == DateTimeConstants.SATURDAY || dayIn.getStart().getDayOfWeek() == DateTimeConstants.SUNDAY)) { // Get difference in millis for the next time block - KPME-2568 endOfFirstDay = endDt.withZone(zone); diffInMillis = endOfFirstDay.minus(beginDt.getMillis()).getMillis(); } else { firstTimeBlock = createTimeBlock(timesheetDocument, beginDateTime, endDt, assignment, earnCode, hours, amount, false, getLunchDeleted, userPrincipalId); lstTimeBlocks.add(firstTimeBlock); } } else { //TODO move this to prerule validation //throw validation error if this case met error } } } DateTime endTime = endDateTime.withZone(zone); if (firstTimeBlock.getEndDateTime() != null) { // KPME-2568 endOfFirstDay = firstTimeBlock.getEndDateTime().withZone(zone); diffInMillis = endOfFirstDay.minus(beginDt.getMillis()).getMillis(); } DateTime currTime = beginDt.plusDays(1); while (currTime.isBefore(endTime) || currTime.isEqual(endTime)) { // KPME-1446 if "Include weekends" check box is checked, don't add Sat and Sun to the timeblock list if (StringUtils.isEmpty(spanningWeeks) && (currTime.getDayOfWeek() == DateTimeConstants.SATURDAY || currTime.getDayOfWeek() == DateTimeConstants.SUNDAY)) { // do nothing } else { TimeBlock tb = createTimeBlock(timesheetDocument, currTime, currTime.plus(diffInMillis), assignment, earnCode, hours, amount, false, getLunchDeleted, userPrincipalId); lstTimeBlocks.add(tb); } currTime = currTime.plusDays(1); } return lstTimeBlocks; }
From source file:org.kuali.kpme.tklm.time.timeblock.service.TimeBlockServiceImpl.java
License:Educational Community License
public List<TimeBlock> buildTimeBlocks(Assignment assignment, String earnCode, TimesheetDocument timesheetDocument, DateTime beginDateTime, DateTime endDateTime, BigDecimal hours, BigDecimal amount, Boolean getClockLogCreated, Boolean getLunchDeleted, String userPrincipalId) { //Create 1 or many timeblocks if the span of timeblocks exceed more than one //day that is determined by pay period day(24 hrs + period begin date) Interval firstDay = null;/*w w w . jav a 2s . co m*/ List<Interval> dayIntervals = TKUtils.getDaySpanForCalendarEntry(timesheetDocument.getCalendarEntry()); List<TimeBlock> lstTimeBlocks = new ArrayList<TimeBlock>(); DateTime currentDateTime = beginDateTime; for (Interval dayInt : dayIntervals) { // the time period spans more than one day if (firstDay != null) { if (!dayInt.contains(endDateTime)) { currentDateTime = dayInt.getStart(); } else if ((dayInt.getStartMillis() - endDateTime.getMillis()) != 0) { TimeBlock tb = createTimeBlock(timesheetDocument, dayInt.getStart(), endDateTime, assignment, earnCode, hours, amount, getClockLogCreated, getLunchDeleted, userPrincipalId); lstTimeBlocks.add(tb); break; } } if (dayInt.contains(currentDateTime)) { firstDay = dayInt; // KPME-361 // added a condition to handle the time block which ends at 12a, e.g. a 10p-12a timeblock // this is the same fix as TkTimeBlockAggregate if (dayInt.contains(endDateTime) || (endDateTime.getMillis() == dayInt.getEnd().getMillis())) { //create one timeblock if contained in one day interval TimeBlock tb = createTimeBlock(timesheetDocument, currentDateTime, endDateTime, assignment, earnCode, hours, amount, getClockLogCreated, getLunchDeleted, userPrincipalId); tb.setBeginDateTime(currentDateTime); tb.setEndDateTime(endDateTime); lstTimeBlocks.add(tb); break; } else { // create a timeblock that wraps the 24 hr day TimeBlock tb = createTimeBlock(timesheetDocument, currentDateTime, dayInt.getEnd(), assignment, earnCode, hours, amount, getClockLogCreated, getLunchDeleted, userPrincipalId); tb.setBeginDateTime(currentDateTime); tb.setEndDateTime(firstDay.getEnd()); lstTimeBlocks.add(tb); } } } return lstTimeBlocks; }
From source file:org.kuali.kpme.tklm.time.util.TkTimeBlockAggregate.java
License:Educational Community License
public TkTimeBlockAggregate(List<TimeBlock> timeBlocks, CalendarEntry payCalendarEntry, Calendar payCalendar, boolean useUserTimeZone, List<Interval> dayIntervals) { this.payCalendarEntry = payCalendarEntry; this.payCalendar = payCalendar; for (Interval dayInt : dayIntervals) { List<TimeBlock> dayTimeBlocks = new ArrayList<TimeBlock>(); for (TimeBlock timeBlock : timeBlocks) { // Assumption: Timezones can only be switched at pay period end boundaries. // If the above assumption becomes false, the logic below will need to // accommodate virtual chopping of time blocks to have them fit nicely // in the "days" that are displayed to users. DateTime beginTime = useUserTimeZone ? timeBlock.getBeginTimeDisplay() : timeBlock.getBeginDateTime().withZone(TKUtils.getSystemDateTimeZone()); DateTime endTime = useUserTimeZone ? timeBlock.getEndTimeDisplay() : timeBlock.getEndDateTime().withZone(TKUtils.getSystemDateTimeZone()); if (dayInt.contains(beginTime)) { if (dayInt.contains(endTime) || endTime.compareTo(dayInt.getEnd()) == 0) { // determine if the time block needs to be pushed forward / backward if (beginTime.getHourOfDay() < dayInt.getStart().getHourOfDay()) { timeBlock.setPushBackward(true); }/*from w w w .j av a 2 s . c o m*/ dayTimeBlocks.add(timeBlock); } } } dayTimeBlockList.add(dayTimeBlocks); } }
From source file:org.kuali.kpme.tklm.time.util.TkTimeBlockAggregate.java
License:Educational Community License
public TkTimeBlockAggregate(List<TimeBlock> timeBlocks, List<LeaveBlock> leaveBlocks, CalendarEntry payCalendarEntry, Calendar payCalendar, boolean useUserTimeZone, List<Interval> dayIntervals) { this.payCalendarEntry = payCalendarEntry; this.payCalendar = payCalendar; for (Interval dayInt : dayIntervals) { List<TimeBlock> dayTimeBlocks = new ArrayList<TimeBlock>(); for (TimeBlock timeBlock : timeBlocks) { // Assumption: Timezones can only be switched at pay period end boundaries. // If the above assumption becomes false, the logic below will need to // accommodate virtual chopping of time blocks to have them fit nicely // in the "days" that are displayed to users. DateTime beginTime = useUserTimeZone ? timeBlock.getBeginTimeDisplay() : new DateTime(timeBlock.getBeginTimestamp(), TKUtils.getSystemDateTimeZone()); DateTime endTime = useUserTimeZone ? timeBlock.getEndTimeDisplay() : new DateTime(timeBlock.getEndTimestamp(), TKUtils.getSystemDateTimeZone()); if (dayInt.contains(beginTime)) { if (dayInt.contains(endTime) || endTime.compareTo(dayInt.getEnd()) == 0) { // determine if the time block needs to be pushed forward / backward if (beginTime.getHourOfDay() < dayInt.getStart().getHourOfDay()) { timeBlock.setPushBackward(true); }/*w w w . j a v a2s. c o m*/ dayTimeBlocks.add(timeBlock); } } } dayTimeBlockList.add(dayTimeBlocks); List<LeaveBlock> dayLeaveBlocks = new ArrayList<LeaveBlock>(); for (LeaveBlock leaveBlock : leaveBlocks) { // Assumption: Timezones can only be switched at pay period end boundaries. // If the above assumption becomes false, the logic below will need to // accommodate virtual chopping of leave blocks to have them fit nicely // in the "days" that are displayed to users. DateTimeZone dateTimeZone = HrServiceLocator.getTimezoneService().getUserTimezoneWithFallback(); DateTime beginTime = new DateTime(leaveBlock.getLeaveDate(), useUserTimeZone ? dateTimeZone : TKUtils.getSystemDateTimeZone()); DateTime endTime = new DateTime(leaveBlock.getLeaveDate(), useUserTimeZone ? dateTimeZone : TKUtils.getSystemDateTimeZone()); if (dayInt.contains(beginTime)) { if (dayInt.contains(endTime) || endTime.compareTo(dayInt.getEnd()) == 0) { dayLeaveBlocks.add(leaveBlock); } } } dayLeaveBlockList.add(dayLeaveBlocks); } }