Example usage for org.joda.time DateTime toLocalDate

List of usage examples for org.joda.time DateTime toLocalDate

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. DateTime
  6. toLocalDate

Introduction

In this page you can find the example usage for org.joda.time DateTime toLocalDate.

Prototype

public LocalDate toLocalDate()

Source Link

Document

Converts this object to a LocalDate with the same date and chronology.

Usage

From source file:org.kuali.kpme.tklm.leave.calendar.service.LeaveCalendarServiceImpl.java

License:Educational Community License

protected LeaveCalendarDocument initiateWorkflowDocument(String principalId, DateTime payBeginDate,
        DateTime payEndDate, CalendarEntry calendarEntry, String documentType, String title)
        throws WorkflowException {
    LeaveCalendarDocument leaveCalendarDocument = null;
    WorkflowDocument workflowDocument = null;

    workflowDocument = WorkflowDocumentFactory.createDocument(principalId, documentType, title);

    String status = workflowDocument.getStatus().getCode();
    LeaveCalendarDocumentHeader documentHeader = new LeaveCalendarDocumentHeader(
            workflowDocument.getDocumentId(), principalId, payBeginDate.toDate(), payEndDate.toDate(), status);

    documentHeader.setDocumentId(workflowDocument.getDocumentId());
    documentHeader.setDocumentStatus(HrConstants.ROUTE_STATUS.INITIATED);

    KRADServiceLocator.getBusinessObjectService().save(documentHeader);

    leaveCalendarDocument = new LeaveCalendarDocument(documentHeader);
    leaveCalendarDocument.setCalendarEntry(calendarEntry);
    loadLeaveCalendarDocumentData(leaveCalendarDocument, principalId, calendarEntry);
    TkServiceLocator.getTkSearchableAttributeService().updateSearchableAttribute(leaveCalendarDocument,
            payEndDate.toLocalDate());

    updateLeaveBlockDocumentIds(principalId, payBeginDate.toLocalDate(), payEndDate.toLocalDate(),
            workflowDocument.getDocumentId());

    updatePlannedLeaveBlocks(principalId, payBeginDate.toLocalDate(), payEndDate.toLocalDate());

    return leaveCalendarDocument;
}

From source file:org.kuali.kpme.tklm.leave.calendar.validation.LeaveCalendarValidationUtil.java

License:Educational Community License

public static List<String> validateAvailableLeaveBalanceForUsage(String earnCode, String leaveStartDateString,
        String leaveEndDateString, BigDecimal leaveAmount, LeaveBlock updatedLeaveBlock) {
    List<String> errors = new ArrayList<String>();
    boolean earnCodeChanged = false;
    BigDecimal oldAmount = null;//from  w  w  w  .jav a  2  s . c  o m

    if (leaveAmount == null) {
        leaveAmount = TKUtils.getHoursBetween(TKUtils.formatDateString(leaveStartDateString).toDate().getTime(),
                TKUtils.formatDateString(leaveEndDateString).toDate().getTime());
    }
    if (updatedLeaveBlock != null) {
        if (!updatedLeaveBlock.getEarnCode().equals(earnCode)) {
            earnCodeChanged = true;
        }
        if (!updatedLeaveBlock.getLeaveAmount().equals(leaveAmount)) {
            oldAmount = updatedLeaveBlock.getLeaveAmount();
        }
    }
    LocalDate startDate = TKUtils.formatDateString(leaveStartDateString);
    LocalDate endDate = TKUtils.formatDateString(leaveEndDateString);
    long daysSpan = TKUtils.getDaysBetween(startDate, endDate);
    EarnCode earnCodeObj = HrServiceLocator.getEarnCodeService().getEarnCode(earnCode, endDate);
    if (earnCodeObj != null && earnCodeObj.getAllowNegativeAccrualBalance().equals("N")) {
        AccrualCategory accrualCategory = HrServiceLocator.getAccrualCategoryService()
                .getAccrualCategory(earnCodeObj.getAccrualCategory(), endDate);
        if (accrualCategory != null) {
            DateTime nextIntervalDate = LmServiceLocator.getAccrualService().getNextAccrualIntervalDate(
                    accrualCategory.getAccrualEarnInterval(), endDate.toDateTimeAtStartOfDay());
            // get the usage checking cut off Date, normally it's the day before the next interval date
            DateTime usageEndDate = nextIntervalDate;
            if (nextIntervalDate.compareTo(endDate.toDateTimeAtCurrentTime()) > 0) {
                usageEndDate = nextIntervalDate.minusDays(1);
            }
            // use the end of the year as the interval date for usage checking of no-accrual hours,
            // normally no-accrual hours are from banked/transferred system scheduled time offs
            if (accrualCategory.getAccrualEarnInterval()
                    .equals(HrConstants.ACCRUAL_EARN_INTERVAL_CODE.NO_ACCRUAL)) {
                usageEndDate = endDate.toDateTimeAtStartOfDay().withMonthOfYear(DateTimeConstants.DECEMBER)
                        .withDayOfMonth(31);
            }
            BigDecimal availableBalance = LmServiceLocator.getLeaveSummaryService()
                    .getLeaveBalanceForAccrCatUpToDate(HrContext.getTargetPrincipalId(), startDate, endDate,
                            accrualCategory.getAccrualCategory(), usageEndDate.toLocalDate());

            if (oldAmount != null) {
                if (!earnCodeChanged || updatedLeaveBlock.getAccrualCategory()
                        .equals(accrualCategory.getAccrualCategory())) {
                    availableBalance = availableBalance.add(oldAmount.abs());
                }
            }
            //multiply by days in span in case the user has also edited the start/end dates.
            BigDecimal desiredUsage = null;
            if (!HrConstants.EARN_CODE_TIME.equals(earnCodeObj.getRecordMethod())) {
                desiredUsage = leaveAmount.multiply(new BigDecimal(daysSpan + 1));
            } else {
                desiredUsage = leaveAmount.multiply(new BigDecimal(daysSpan));
            }

            if (desiredUsage.compareTo(availableBalance) > 0) {
                errors.add("Requested leave amount " + desiredUsage.toString()
                        + " is greater than available leave balance " + availableBalance.toString()); //errorMessages
            }
        }
    }

    return errors;
}

From source file:org.kuali.kpme.tklm.leave.calendar.validation.LeaveCalendarValidationUtil.java

License:Educational Community License

public static List<String> validateParametersForLeaveEntry(String selectedEarnCode, CalendarEntry leaveCalEntry,
        String startDateS, String endDateS, String startTimeS, String endTimeS, String selectedAssignment,
        LeaveCalendarDocument leaveCalendarDocument, String leaveBlockId) {
    List<String> errors = new ArrayList<String>();
    if (StringUtils.isNotBlank(selectedEarnCode)) {
        EarnCode earnCode = HrServiceLocator.getEarnCodeService().getEarnCode(selectedEarnCode,
                leaveCalEntry.getEndPeriodFullDateTime().toLocalDate());

        if (earnCode != null && earnCode.getRecordMethod().equalsIgnoreCase(HrConstants.EARN_CODE_TIME)) {

            errors.addAll(LeaveCalendarValidationUtil.validateDates(startDateS, endDateS));
            errors.addAll(LeaveCalendarValidationUtil.validateTimes(startTimeS, endTimeS));
            if (errors.size() > 0)
                return errors;

            Long startTime;/*from   w w w .  j  a  v a 2 s .  com*/
            Long endTime;

            startTime = TKUtils.convertDateStringToDateTimeWithoutZone(startDateS, startTimeS).getMillis();
            endTime = TKUtils.convertDateStringToDateTimeWithoutZone(endDateS, endTimeS).getMillis();

            errors.addAll(validateInterval(leaveCalEntry, startTime, endTime));
            if (errors.size() > 0)
                return errors;

            if (startTimeS == null)
                errors.add("The start time is blank.");
            if (endTimeS == null)
                errors.add("The end time is blank.");
            if (startTime - endTime == 0)
                errors.add("Start time and end time cannot be equivalent");

            if (errors.size() > 0)
                return errors;

            DateTime startTemp = new DateTime(startTime);
            DateTime endTemp = new DateTime(endTime);

            if (errors.size() == 0) {
                Hours hrs = Hours.hoursBetween(startTemp, endTemp);
                if (hrs.getHours() >= 24)
                    errors.add("One leaveblock cannot exceed 24 hours");
            }
            if (errors.size() > 0)
                return errors;

            //Check that assignment is valid for both days
            AssignmentDescriptionKey assignKey = HrServiceLocator.getAssignmentService()
                    .getAssignmentDescriptionKey(selectedAssignment);
            Assignment assign = HrServiceLocator.getAssignmentService().getAssignment(assignKey,
                    startTemp.toLocalDate());

            if ((startTime.compareTo(endTime) > 0 || endTime.compareTo(startTime) < 0)) {
                errors.add("The time or date is not valid.");
            }
            if (errors.size() > 0)
                return errors;

            //              boolean isRegularEarnCode = StringUtils.equals(assign.getJob().getPayTypeObj().getRegEarnCode(),selectedEarnCode);
            boolean isRegularEarnCode = true;
            errors.addAll(validateOverlap(startTime, endTime, startDateS, endTimeS, startTemp, endTemp,
                    leaveCalEntry, leaveBlockId, isRegularEarnCode, earnCode.getRecordMethod()));
            if (errors.size() > 0)
                return errors;
        }
    }
    return errors;
}

From source file:org.kuali.kpme.tklm.leave.calendar.web.LeaveCalendarAction.java

License:Educational Community License

public ActionForward addLeaveBlock(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) throws Exception {
    LeaveCalendarForm lcf = (LeaveCalendarForm) form;
    LeaveCalendarDocument lcd = lcf.getLeaveCalendarDocument();

    String principalId = HrContext.getPrincipalId();
    String targetPrincipalId = HrContext.getTargetPrincipalId();
    CalendarEntry calendarEntry = lcf.getCalendarEntry();
    String selectedAssignment = lcf.getSelectedAssignment();

    DateTime beginDate = null;/*from w ww. jav a  2s.com*/
    DateTime endDate = null;

    /** -- Jignasha : if earchcode type is 'T' then change the date and time with timezone.
    // Surgery point - Need to construct a Date/Time with Appropriate Timezone.
     * */
    LOG.debug("Start time is " + lcf.getStartTime());
    LOG.debug("Emnd time is " + lcf.getEndTime());
    if (lcf.getStartTime() != null && lcf.getEndTime() != null) {
        beginDate = TKUtils.convertDateStringToDateTimeWithoutZone(lcf.getStartDate(), lcf.getStartTime());
        endDate = TKUtils.convertDateStringToDateTimeWithoutZone(lcf.getEndDate(), lcf.getEndTime());
    } else {
        beginDate = TKUtils.formatDateTimeStringNoTimezone(lcf.getStartDate());
        endDate = TKUtils.formatDateTimeStringNoTimezone(lcf.getEndDate());
    }
    LOG.debug("Begin Date is>> " + beginDate);
    LOG.debug("End Date is>> " + endDate);

    String selectedEarnCode = lcf.getSelectedEarnCode();
    BigDecimal hours = lcf.getLeaveAmount();
    String desc = lcf.getDescription();
    String spanningWeeks = lcf.getSpanningWeeks(); // KPME-1446
    String approval = lcf.getApproval(); // KPME-2540

    String documentId = lcd != null ? lcd.getDocumentId() : "";

    Assignment assignment = null;
    if (lcd != null) {
        assignment = lcd.getAssignment(AssignmentDescriptionKey.get(selectedAssignment));
        if (assignment == null)
            LOG.warn("No matched assignment found");
    } else {
        List<Assignment> assignments = HrServiceLocator.getAssignmentService()
                .getAssignmentsByCalEntryForLeaveCalendar(targetPrincipalId, calendarEntry);
        assignment = HrServiceLocator.getAssignmentService().getAssignment(assignments, selectedAssignment,
                calendarEntry.getBeginPeriodFullDateTime().toLocalDate());
    }
    LmServiceLocator.getLeaveBlockService().addLeaveBlocks(beginDate, endDate, calendarEntry, selectedEarnCode,
            hours, desc, assignment, spanningWeeks, LMConstants.LEAVE_BLOCK_TYPE.LEAVE_CALENDAR,
            targetPrincipalId);

    generateLeaveCalendarChangedNotification(principalId, targetPrincipalId, documentId,
            calendarEntry.getHrCalendarEntryId());

    // after adding the leave block, set the fields of this form to null for future new leave blocks
    lcf.setLeaveAmount(null);
    lcf.setDescription(null);

    // call accrual service if earn code is not eligible for accrual
    if (calendarEntry != null) {
        this.rerunAccrualForNotEligibleForAccrualChanges(selectedEarnCode, endDate.toLocalDate(),
                calendarEntry.getBeginPeriodFullDateTime().toLocalDate(),
                calendarEntry.getEndPeriodFullDateTime().toLocalDate());
    }
    // recalculate summary
    if (calendarEntry != null) {
        LeaveSummary ls = LmServiceLocator.getLeaveSummaryService().getLeaveSummary(targetPrincipalId,
                calendarEntry);
        lcf.setLeaveSummary(ls);
    }

    // KPME-2540 replicate submitForApproval method in LeaveRequestAction here
    if (!StringUtils.isEmpty(approval)) {
        List<LeaveBlock> leaveBlocks = LmServiceLocator.getLeaveBlockService().getLeaveBlocks(targetPrincipalId,
                beginDate.toLocalDate(), endDate.toLocalDate());
        for (LeaveBlock leaveBlock : leaveBlocks) {
            LeaveRequestDocument lrd = LmServiceLocator.getLeaveRequestDocumentService()
                    .createLeaveRequestDocument(leaveBlock.getLmLeaveBlockId());
            LmServiceLocator.getLeaveRequestDocumentService().requestLeave(lrd.getDocumentNumber());
        }
    }

    return mapping.findForward("basic");
}

From source file:org.kuali.kpme.tklm.leave.calendar.web.LeaveCalendarAction.java

License:Educational Community License

protected void setLeaveSummary(LeaveCalendarForm leaveCalendarForm) throws Exception {
    String principalId = HrContext.getTargetPrincipalId();
    CalendarEntry calendarEntry = leaveCalendarForm.getCalendarEntry();
    PrincipalHRAttributes principalHRAttributes = HrServiceLocator.getPrincipalHRAttributeService()
            .getPrincipalCalendar(principalId, calendarEntry.getEndPeriodFullDateTime().toLocalDate());

    //check to see if we are on a previous leave plan
    if (principalHRAttributes != null) {
        DateTime currentYearBeginDate = HrServiceLocator.getLeavePlanService()
                .getFirstDayOfLeavePlan(principalHRAttributes.getLeavePlan(), LocalDate.now());
        DateTime calEntryEndDate = calendarEntry.getEndPeriodFullDateTime();
        if (calEntryEndDate.getMillis() > currentYearBeginDate.getMillis()) {
            //current or future year
            LeaveSummary ls = LmServiceLocator.getLeaveSummaryService().getLeaveSummary(principalId,
                    calendarEntry);//from  ww  w  .j a  va2s .  c  o  m
            leaveCalendarForm.setLeaveSummary(ls);
        } else {
            //current year roll over date has been passed, all previous calendars belong to the previous leave plan calendar year.
            DateTime effDate = HrServiceLocator.getLeavePlanService().getRolloverDayOfLeavePlan(
                    principalHRAttributes.getLeavePlan(), calEntryEndDate.minusDays(1).toLocalDate());
            LeaveSummary ls = LmServiceLocator.getLeaveSummaryService()
                    .getLeaveSummaryAsOfDateWithoutFuture(principalId, effDate.toLocalDate());
            //override title element (based on date passed in)
            DateFormat formatter = new SimpleDateFormat("MMMM d");
            DateFormat formatter2 = new SimpleDateFormat("MMMM d yyyy");
            DateTime entryEndDate = new LocalDateTime(calendarEntry.getEndPeriodDate()).toDateTime();
            if (entryEndDate.getHourOfDay() == 0) {
                entryEndDate = entryEndDate.minusDays(1);
            }
            String aString = formatter.format(calendarEntry.getBeginPeriodDate()) + " - "
                    + formatter2.format(entryEndDate.toDate());
            ls.setPendingDatesString(aString);
            DateTimeFormatter fmt = DateTimeFormat.forPattern("MMM d, yyyy");
            ls.setNote("Values as of: " + fmt.print(effDate));
            leaveCalendarForm.setLeaveSummary(ls);
        }
    }
}

From source file:org.kuali.kpme.tklm.leave.calendar.web.LeaveCalendarWSAction.java

License:Educational Community License

public ActionForward getEarnCodeJson(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) throws Exception {
    LeaveCalendarWSForm lcf = (LeaveCalendarWSForm) form;

    List<Map<String, Object>> earnCodeList = new LinkedList<Map<String, Object>>();

    CalendarEntry calendarEntry = lcf.getCalendarEntry();
    if (StringUtils.isNotBlank(lcf.getSelectedAssignment())) {
        LocalDate asOfDate = calendarEntry.getEndPeriodFullDateTime().toLocalDate();

        if (lcf.getStartDate() != null) {
            try {
                DateTime utilDate = HrConstants.DateTimeFormats.BASIC_DATE_FORMAT
                        .parseDateTime(lcf.getStartDate());
                asOfDate = utilDate.toLocalDate();
            } catch (Exception ex) {
                //ignore and use the timesheet as of date.
            }// w ww .j  a v  a  2 s  .  c  o  m
        }
        Map<LocalDate, List<Assignment>> assignments = HrServiceLocator.getAssignmentService()
                .getAssignmentsByCalEntryForLeaveCalendar(HrContext.getTargetPrincipalId(), calendarEntry);
        boolean leavePlanningCalendar = LmServiceLocator.getLeaveCalendarService().isLeavePlanningCalendar(
                HrContext.getTargetPrincipalId(), calendarEntry.getBeginPeriodFullDateTime().toLocalDate(),
                calendarEntry.getEndPeriodFullDateTime().toLocalDate());
        AssignmentDescriptionKey key = AssignmentDescriptionKey.get(lcf.getSelectedAssignment());
        List<Assignment> dayAssigns = assignments.get(asOfDate);
        for (Assignment assignment : dayAssigns) {
            if (assignment.getJobNumber().compareTo(key.getJobNumber()) == 0
                    && assignment.getWorkArea().compareTo(key.getWorkArea()) == 0
                    && assignment.getTask().compareTo(key.getTask()) == 0) {
                List<EarnCode> earnCodes = HrServiceLocator.getEarnCodeService()
                        .getEarnCodesForLeave(assignment, asOfDate, leavePlanningCalendar);
                for (EarnCode earnCode : earnCodes) {
                    Map<String, Object> earnCodeMap = new HashMap<String, Object>();
                    earnCodeMap.put("assignment", assignment.getAssignmentKey());
                    earnCodeMap.put("earnCode", earnCode.getEarnCode());
                    earnCodeMap.put("desc", earnCode.getDescription());
                    earnCodeMap.put("type", earnCode.getEarnCodeType());
                    earnCodeMap.put("earnCodeId", earnCode.getHrEarnCodeId());
                    earnCodeMap.put("unitOfTime", earnCode.getRecordMethod());
                    earnCodeMap.put("defaultAmountofTime", earnCode.getDefaultAmountofTime());
                    earnCodeMap.put("fractionalTimeAllowed", earnCode.getFractionalTimeAllowed());
                    earnCodeList.add(earnCodeMap);
                }
            }
        }
    }

    LOG.info(lcf.toString());
    lcf.setOutputString(JSONValue.toJSONString(earnCodeList));

    return mapping.findForward("ws");
}

From source file:org.kuali.kpme.tklm.leave.calendar.web.LeaveCalendarWSAction.java

License:Educational Community License

public ActionForward getValidAssignments(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) throws Exception {
    TimeDetailWSActionForm tdaf = (TimeDetailWSActionForm) form;

    //need an asOfDate here
    LocalDate asOfDate = tdaf.getTimesheetDocument().getAsOfDate();

    if (tdaf.getStartDate() != null) {
        try {//from  w w w. j a  va2 s.co m
            DateTime utilDate = HrConstants.DateTimeFormats.BASIC_DATE_FORMAT
                    .parseDateTime(tdaf.getStartDate());
            asOfDate = utilDate.toLocalDate();
        } catch (Exception ex) {
            //ignore and use the timesheet as of date.
        }
    }
    String earnCode = tdaf.getSelectedEarnCode();

    List<Map<String, Object>> assignments = new ArrayList<Map<String, Object>>();
    if (tdaf.getTimesheetDocument() != null && StringUtils.isNotEmpty(earnCode)) {
        assignments = getAssignmentsForRegEarnCode(tdaf.getTimesheetDocument().getAssignmentMap().get(asOfDate),
                earnCode, asOfDate);
    }
    tdaf.setOutputString(JSONValue.toJSONString(assignments));
    return mapping.findForward("ws");
}

From source file:org.kuali.kpme.tklm.leave.calendar.web.LeaveCalendarWSAction.java

License:Educational Community License

public ActionForward getAssignmentJson(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) throws Exception {
    LeaveCalendarWSForm lcf = (LeaveCalendarWSForm) form;
    String earnCode = lcf.getSelectedEarnCode();
    LocalDate asOfDate = null;/*from  ww  w .ja va2  s .c o  m*/
    if (lcf.getStartDate() != null) {
        try {
            DateTime utilDate = HrConstants.DateTimeFormats.BASIC_DATE_FORMAT.parseDateTime(lcf.getStartDate());
            asOfDate = utilDate.toLocalDate();
        } catch (Exception ex) {
            //ignore and use the leaveCalendar as of date.
        }
    }
    List<Map<String, Object>> assignments = new ArrayList<Map<String, Object>>();
    if (asOfDate == null) {
        Map<String, Object> assignmentMap = new HashMap<String, Object>(2);
        assignmentMap.put("assignment", "");
        assignmentMap.put("desc", "-- enter valid date range --");
        assignments.add(assignmentMap);
    }
    lcf.setLeaveCalendarDocument(
            LmServiceLocator.getLeaveCalendarService().getLeaveCalendarDocument(lcf.getDocumentId()));
    if (lcf.getLeaveCalendarDocument() != null && asOfDate != null) {
        //check date to see if assignment is active
        String principalId = lcf.getLeaveCalendarDocument().getPrincipalId();
        CalendarEntry ce = lcf.getLeaveCalendarDocument().getCalendarEntry();
        Map<LocalDate, List<Assignment>> history = lcf.getLeaveCalendarDocument().getAssignmentMap();
        List<Assignment> dayAssignments = history.get(asOfDate);
        dayAssignments = HrServiceLocator.getAssignmentService()
                .filterAssignmentListForUser(HrContext.getPrincipalId(), dayAssignments);
        if (CollectionUtils.isNotEmpty(dayAssignments)) {
            if (dayAssignments.size() > 1) {
                Map<String, Object> assignmentMap = new HashMap<String, Object>(2);
                assignmentMap.put("assignment", "");
                assignmentMap.put("desc", "-- select an assignment --");
                assignments.add(assignmentMap);
            }
            for (Assignment a : dayAssignments) {
                Map<String, Object> assignmentMap = new HashMap<String, Object>(2);
                assignmentMap.put("assignment", a.getAssignmentKey());
                assignmentMap.put("desc", HrServiceLocator.getAssignmentService()
                        .getAssignmentDescriptionForAssignment(a, asOfDate));
                assignments.add(assignmentMap);
            }
        }
    }

    lcf.setOutputString(JSONValue.toJSONString(assignments));
    return mapping.findForward("ws");
}

From source file:org.kuali.kpme.tklm.leave.request.web.LeaveRequestAction.java

License:Educational Community License

@Override
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) throws Exception {
    ActionForward forward = super.execute(mapping, form, request, response);
    LeaveRequestForm leaveForm = (LeaveRequestForm) form;
    String principalId = HrContext.getTargetPrincipalId();
    DateTime currentDate = LocalDate.now().toDateTimeAtStartOfDay();

    if (leaveForm.getNavString() == null) {
        leaveForm.setYear(LocalDate.now().getYear());
    } else if (leaveForm.getNavString().equals("NEXT")) {
        leaveForm.setYear(leaveForm.getYear() + 1);
    } else if (leaveForm.getNavString().equals("PREV")) {
        leaveForm.setYear(leaveForm.getYear() - 1);
    }/*from  w ww  .  j  a va 2s .  com*/
    LocalDate beginDate = new LocalDate(leaveForm.getYear(), 1, 1);
    LocalDate endDate = new LocalDate(leaveForm.getYear(), 12, 31);

    //        CalendarEntry calendarEntry = HrServiceLocator.getCalendarService().getCurrentCalendarDatesForLeaveCalendar(principalId, currentDate);
    CalendarEntry calendarEntry = HrServiceLocator.getCalendarEntryService()
            .getCurrentCalendarDatesForLeaveCalendar(principalId, beginDate.toDateTimeAtStartOfDay(),
                    endDate.toDateTimeAtStartOfDay());

    //  If the current pay period ends before the current leave calendar ends, then we need to include any planned leave blocks that occur
    //  in this window between the current pay end and the beginning of the leave planning calendar (the next future leave period).
    //  The most common scenario occurs when a non-monthly pay period ends before the current leave calendar ends.

    CalendarEntry payCalendarEntry = HrServiceLocator.getCalendarEntryService().getCurrentCalendarDates(
            principalId, beginDate.toDateTimeAtStartOfDay(), endDate.toDateTimeAtStartOfDay());
    Boolean checkLeaveEligible = true;
    Boolean nonExemptLeaveEligible = LmServiceLocator.getLeaveApprovalService()
            .isActiveAssignmentFoundOnJobFlsaStatus(principalId, HrConstants.FLSA_STATUS_NON_EXEMPT,
                    checkLeaveEligible);
    if (nonExemptLeaveEligible && calendarEntry != null && payCalendarEntry != null) {
        if (payCalendarEntry.getEndPeriodDate().before(calendarEntry.getEndPeriodDate())) {
            calendarEntry = payCalendarEntry;
        }
    }

    if (calendarEntry != null) {
        if (calendarEntry.getEndPeriodLocalDateTime().getMillisOfDay() == 0) {
            // if the time of the end date is the beginning of a day, subtract one day from the end date
            currentDate = calendarEntry.getEndPeriodFullDateTime().minusDays(1);
        } else {
            currentDate = calendarEntry.getEndPeriodFullDateTime(); // only show leave requests from planning calendars on leave request page
        }
    }
    List<LeaveBlock> plannedLeaves = getLeaveBlocksWithRequestStatus(principalId, beginDate, endDate,
            HrConstants.REQUEST_STATUS.PLANNED);
    plannedLeaves.addAll(getLeaveBlocksWithRequestStatus(principalId, beginDate, endDate,
            HrConstants.REQUEST_STATUS.DEFERRED));
    leaveForm.setPlannedLeaves(plannedLeaves);
    leaveForm.setPendingLeaves(getLeaveBlocksWithRequestStatus(principalId, beginDate, endDate,
            HrConstants.REQUEST_STATUS.REQUESTED));
    leaveForm.setApprovedLeaves(getLeaveBlocksWithRequestStatus(principalId, beginDate, endDate,
            HrConstants.REQUEST_STATUS.APPROVED));
    leaveForm.setDisapprovedLeaves(getDisapprovedLeaveBlockHistory(principalId, currentDate.toLocalDate()));

    leaveForm.setDocuments(getLeaveRequestDocuments(leaveForm));
    return forward;
}

From source file:org.kuali.kpme.tklm.leave.workflow.postprocessor.LmPostProcessor.java

License:Educational Community License

private void calculateMaxCarryOver(LeaveCalendarDocumentHeader leaveCalendarDocumentHeader,
        DocumentStatus newDocumentStatus) {
    String documentId = leaveCalendarDocumentHeader.getDocumentId();
    String principalId = leaveCalendarDocumentHeader.getPrincipalId();
    DateTime endDate = leaveCalendarDocumentHeader.getEndDateTime();
    if (DocumentStatus.ENROUTE.equals(newDocumentStatus)) {
        //create pending carry over leave blocks.

        Calendar calendar = HrServiceLocator.getCalendarService().getCalendarByPrincipalIdAndDate(principalId,
                endDate.toLocalDate(), true);

        if (calendar != null) {
            CalendarEntry calendarEntry = HrServiceLocator.getCalendarEntryService()
                    .getCalendarEntryByIdAndPeriodEndDate(calendar.getHrCalendarId(), endDate);

            LmServiceLocator.getAccrualCategoryMaxCarryOverService().calculateMaxCarryOver(documentId,
                    principalId, calendarEntry, endDate.toLocalDate());
        }/*w  w w  .  j  a v  a2 s.  c o m*/
    } else if (DocumentStatus.FINAL.equals(newDocumentStatus)) {
        //approve the carry over leave block.
        List<LeaveBlock> leaveBlocks = LmServiceLocator.getLeaveBlockService().getLeaveBlocks(principalId,
                leaveCalendarDocumentHeader.getBeginDateTime().toLocalDate(), endDate.toLocalDate());
        for (LeaveBlock lb : leaveBlocks) {
            if (StringUtils.equals(lb.getLeaveBlockType(),
                    LMConstants.LEAVE_BLOCK_TYPE.CARRY_OVER_ADJUSTMENT)) {
                lb.setRequestStatus(HrConstants.REQUEST_STATUS.APPROVED);
                LmServiceLocator.getLeaveBlockService().updateLeaveBlock(lb, lb.getPrincipalIdModified());
            }
        }
    }
}