Example usage for org.joda.time LocalDate isAfter

List of usage examples for org.joda.time LocalDate isAfter

Introduction

In this page you can find the example usage for org.joda.time LocalDate isAfter.

Prototype

public boolean isAfter(ReadablePartial partial) 

Source Link

Document

Is this partial later than the specified partial.

Usage

From source file:org.killbill.billing.overdue.config.DefaultCondition.java

License:Apache License

@Override
public boolean evaluate(final BillingState state, final LocalDate date) {
    LocalDate unpaidInvoiceTriggerDate = null;
    if (timeSinceEarliestUnpaidInvoiceEqualsOrExceeds != null
            && state.getDateOfEarliestUnpaidInvoice() != null) { // no date => no unpaid invoices
        unpaidInvoiceTriggerDate = state.getDateOfEarliestUnpaidInvoice()
                .plus(timeSinceEarliestUnpaidInvoiceEqualsOrExceeds.toJodaPeriod());
    }//from   w  w w  . ja v a 2  s  . c o m

    return (numberOfUnpaidInvoicesEqualsOrExceeds == null
            || state.getNumberOfUnpaidInvoices() >= numberOfUnpaidInvoicesEqualsOrExceeds)
            && (totalUnpaidInvoiceBalanceEqualsOrExceeds == null || totalUnpaidInvoiceBalanceEqualsOrExceeds
                    .compareTo(state.getBalanceOfUnpaidInvoices()) <= 0)
            && (timeSinceEarliestUnpaidInvoiceEqualsOrExceeds == null
                    || (unpaidInvoiceTriggerDate != null && !unpaidInvoiceTriggerDate.isAfter(date)))
            && (responseForLastFailedPayment == null
                    || responseIsIn(state.getResponseForLastFailedPayment(), responseForLastFailedPayment))
            && (controlTag == null || isTagIn(controlTag, state.getTags()));
}

From source file:org.killbill.billing.plugin.analytics.reports.ReportsUserApi.java

License:Apache License

private void normalizeAndSortXValues(final Map<String, Map<String, List<XY>>> dataForReports,
        @Nullable final LocalDate startDate, @Nullable final LocalDate endDate) {
    LocalDate minDate = null;/*from   w  w w.jav  a 2s. c o m*/
    if (startDate != null) {
        minDate = startDate;
    }

    LocalDate maxDate = null;
    if (endDate != null) {
        maxDate = endDate;
    }

    // If no min and/or max was specified, infer them from the data
    if (minDate == null || maxDate == null) {
        for (final Map<String, List<XY>> dataForReport : dataForReports.values()) {
            for (final List<XY> dataForPivot : dataForReport.values()) {
                for (final XY xy : dataForPivot) {
                    if (minDate == null || xy.getxDate().isBefore(minDate)) {
                        minDate = xy.getxDate();
                    }
                    if (maxDate == null || xy.getxDate().isAfter(maxDate)) {
                        maxDate = xy.getxDate();
                    }
                }
            }
        }
    }

    if (minDate == null || maxDate == null) {
        throw new IllegalStateException(String.format(
                "minDate and maxDate shouldn't be null! minDate=%s, maxDate=%s, dataForReports=%s", minDate,
                maxDate, dataForReports));
    }

    // Add 0 for missing days
    LocalDate curDate = minDate;
    while (!curDate.isAfter(maxDate)) {
        for (final Map<String, List<XY>> dataForReport : dataForReports.values()) {
            for (final List<XY> dataForPivot : dataForReport.values()) {
                addMissingValueForDateIfNeeded(curDate, dataForPivot);
            }
        }
        curDate = curDate.plusDays(1);
    }

    // Sort the data for the dashboard
    for (final String reportName : dataForReports.keySet()) {
        for (final String pivotName : dataForReports.get(reportName).keySet()) {
            Collections.sort(dataForReports.get(reportName).get(pivotName), new Comparator<XY>() {
                @Override
                public int compare(final XY o1, final XY o2) {
                    return o1.getxDate().compareTo(o2.getxDate());
                }
            });
        }
    }
}

From source file:org.killbill.billing.plugin.analytics.utils.CurrencyConverter.java

License:Apache License

public BigDecimal getConvertedValue(@Nullable final BigDecimal value, @Nullable final String currency,
        @Nullable final LocalDate effectiveDate) {
    // No data// w w w  .j  a v  a  2s. c  o m
    if (referenceCurrency == null) {
        return null;
    }

    // Optimization
    if (referenceCurrency.equals(currency)) {
        return value;
    }

    if (value == null || currency == null || effectiveDate == null
            || currencyConversions.get(currency) == null) {
        return null;
    }

    CurrencyConversionModelDao currencyConversionCandidate = null;
    for (final CurrencyConversionModelDao currencyConversionModelDao : currencyConversions.get(currency)) {
        if (!effectiveDate.isBefore(currencyConversionModelDao.getStartDate())
                && !effectiveDate.isAfter(currencyConversionModelDao.getEndDate()) &&
                // In case of overlapping ranges, use the narrowest one
                (currencyConversionCandidate == null || currencyConversionModelDao.getStartDate()
                        .isAfter(currencyConversionCandidate.getStartDate()))) {
            currencyConversionCandidate = currencyConversionModelDao;
        }
    }

    if (currencyConversionCandidate == null) {
        return null;
    } else {
        return value.multiply(currencyConversionCandidate.getReferenceRate());
    }
}

From source file:org.killbill.billing.plugin.simpletax.resolving.InvoiceItemEndDateBasedResolver.java

License:Apache License

@Override
public TaxCode applicableCodeForItem(Iterable<TaxCode> taxCodes, InvoiceItem item) {
    DateTimeZone accountTimeZone = account.getTimeZone();
    DateTimeZone taxationTimeZone = cfg.getTaxationTimeZone();

    LocalDate applicableDate = firstNonNull(item.getEndDate(), item.getStartDate());

    final LocalDate taxationDate = taxationTimeZone == null ? applicableDate
            : convertTimeZone(applicableDate, accountTimeZone, taxationTimeZone);

    return tryFind(taxCodes, new Predicate<TaxCode>() {
        @Override//from ww w  . ja v  a 2 s.  co m
        public boolean apply(TaxCode taxCode) {
            LocalDate startDay = taxCode.getStartingOn();
            if ((startDay != null) && taxationDate.isBefore(startDay)) {
                return false;
            }
            LocalDate stopDay = taxCode.getStoppingOn();
            if ((stopDay != null) && (taxationDate.isEqual(stopDay) || taxationDate.isAfter(stopDay))) {
                return false;
            }
            return true;
        }
    }).orNull();
}

From source file:org.kitodo.production.forms.CalendarForm.java

License:Open Source License

/**
 * The function checkBlockPlausibility compares the dates entered against
 * some plausibility assumptions and sets hints otherwise.
 *///  w w w . j a v  a  2  s  .c om
private void checkBlockPlausibility() {
    LocalDate firstAppearance = blockShowing.getFirstAppearance();
    LocalDate lastAppearance = blockShowing.getLastAppearance();
    if (Objects.nonNull(firstAppearance) && Objects.nonNull(lastAppearance)) {
        if (firstAppearance.plusYears(100).isBefore(lastAppearance)) {
            Helper.setMessage(BLOCK + "long");
        }
        if (firstAppearance.isAfter(lastAppearance)) {
            Helper.setErrorMessage(BLOCK_NEGATIVE);
        }
        if (firstAppearance.isBefore(START_RELATION)) {
            Helper.setMessage(BLOCK + "firstAppearance.early");
        }
        if (firstAppearance.isAfter(today)) {
            Helper.setMessage(BLOCK + "firstAppearance.fiction");
        }
        if (lastAppearance.isBefore(START_RELATION)) {
            Helper.setMessage(BLOCK + "lastAppearance.early");
        }
        if (lastAppearance.isAfter(today)) {
            Helper.setMessage(BLOCK + "lastAppearance.fiction");
        }
    }
}

From source file:org.kuali.kpme.core.earncode.service.EarnCodeServiceImpl.java

License:Educational Community License

@Override
public Map<String, String> getEarnCodesForDisplayWithEffectiveDate(String principalId, LocalDate asOfDate,
        boolean isLeavePlanningCalendar) {
    List<EarnCode> earnCodes = this.getEarnCodesForPrincipal(principalId, asOfDate, isLeavePlanningCalendar);

    boolean futureDate = asOfDate.isAfter(LocalDate.now());
    List<EarnCode> copyList = new ArrayList<EarnCode>();
    copyList.addAll(earnCodes);// w w w  .  ja  v a  2  s  .com
    for (EarnCode earnCode : copyList) {
        if (futureDate && !earnCode.getAllowScheduledLeave().equalsIgnoreCase("Y")) {
            earnCodes.remove(earnCode);
        }
    }
    Comparator<EarnCode> earnCodeComparator = new Comparator<EarnCode>() {
        @Override
        public int compare(EarnCode ec1, EarnCode ec2) {
            return ec1.getEarnCode().compareToIgnoreCase(ec2.getEarnCode());
        }
    };
    // Order by leaveCode ascending
    Ordering<EarnCode> ordering = Ordering.from(earnCodeComparator);

    Map<String, String> earnCodesForDisplay = new LinkedHashMap<String, String>();
    for (EarnCode earnCode : ordering.sortedCopy(earnCodes)) {
        earnCodesForDisplay.put(earnCode.getEarnCodeKeyForDisplay(), earnCode.getEarnCodeValueForDisplay());
    }
    return earnCodesForDisplay;
}

From source file:org.kuali.kpme.core.leaveplan.service.LeavePlanServiceImpl.java

License:Educational Community License

@Override
public DateTime getRolloverDayOfLeavePlan(String leavePlan, LocalDate asOfDate) {
    LeavePlan lp = getLeavePlan(leavePlan, asOfDate);

    int priorYearCutOffMonth = Integer.parseInt(lp.getCalendarYearStartMonth());
    int priorYearCutOffDay = Integer.parseInt(lp.getCalendarYearStartDayOfMonth());

    LocalDate cutOffDate = asOfDate.withMonthOfYear(priorYearCutOffMonth).withDayOfMonth(priorYearCutOffDay);
    if (asOfDate.isAfter(cutOffDate) || asOfDate.equals(cutOffDate)) {
        cutOffDate = cutOffDate.plusYears(1);
    }/*www.j  a v  a2s. c  o m*/
    return cutOffDate.toDateTimeAtStartOfDay();
}

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

License:Educational Community License

public LeaveCalendar(String principalId, CalendarEntry calendarEntry, List<String> assignmentKeys) {
    super(calendarEntry);

    DateTime currentDisplayDateTime = getBeginDateTime();
    DateTime endDisplayDateTime = getEndDateTime();

    // Fill in the days if the first day or end day is in the middle of the week
    if (currentDisplayDateTime.getDayOfWeek() != DateTimeConstants.SUNDAY) {
        currentDisplayDateTime = currentDisplayDateTime.minusDays(currentDisplayDateTime.getDayOfWeek());
    }/*w w  w .jav a 2  s .c om*/
    if (endDisplayDateTime.getDayOfWeek() != DateTimeConstants.SATURDAY) {
        endDisplayDateTime = endDisplayDateTime
                .plusDays(DateTimeConstants.SATURDAY - endDisplayDateTime.getDayOfWeek());
    }

    LeaveCalendarWeek leaveCalendarWeek = new LeaveCalendarWeek();
    Integer dayNumber = 0;
    List<LeaveBlock> blocks = LmServiceLocator.getLeaveBlockService().getLeaveBlocks(principalId,
            calendarEntry.getBeginPeriodFullDateTime().toLocalDate(),
            calendarEntry.getEndPeriodFullDateTime().toLocalDate());
    Map<String, List<LeaveBlock>> leaveBlockMap = new HashMap<String, List<LeaveBlock>>();
    for (LeaveBlock lb : blocks) {
        String key = lb.getLeaveLocalDate().toString();
        if (leaveBlockMap.containsKey(key)) {
            leaveBlockMap.get(key).add(lb);
        } else {
            leaveBlockMap.put(key, createNewLeaveBlockList(lb));
        }
    }

    //KPME-2560 If leave calendar document is final status, then User wont be able to add leave blocks to the calendar. 
    Boolean dayEditableFlag = true;
    LeaveCalendarDocumentHeader header = LmServiceLocator.getLeaveCalendarDocumentHeaderService()
            .getDocumentHeader(principalId, calendarEntry.getBeginPeriodFullDateTime(),
                    calendarEntry.getEndPeriodFullDateTime());
    if (header != null && header.getDocumentStatus().equals(HrConstants.ROUTE_STATUS.FINAL))
        dayEditableFlag = false;

    while (currentDisplayDateTime.isBefore(endDisplayDateTime)
            || currentDisplayDateTime.isEqual(endDisplayDateTime)) {
        LeaveCalendarDay leaveCalendarDay = new LeaveCalendarDay();

        // If the day is not within the current pay period, mark them as read only (gray)
        if (currentDisplayDateTime.isBefore(getBeginDateTime())
                || currentDisplayDateTime.isEqual(getEndDateTime())
                || currentDisplayDateTime.isAfter(getEndDateTime())) {
            leaveCalendarDay.setGray(true);
        } else {
            // This is for the div id of the days on the calendar.
            // It creates a day id like day_11/01/2011 which will make day parsing easier in the javascript.
            //                leaveCalendarDay.setDayNumberDelta(currDateTime.toString(HrConstants.DT_BASIC_DATE_FORMAT));
            //                leaveCalendarDay.setDayNumberDelta(currDateTime.getDayOfMonth());
            leaveCalendarDay.setDayNumberDelta(dayNumber);

            LocalDate leaveDate = currentDisplayDateTime.toLocalDate();
            List<LeaveBlock> lbs = leaveBlockMap.get(currentDisplayDateTime.toLocalDate().toString());
            if (lbs == null) {
                lbs = Collections.emptyList();
            }
            // use given assignmentKeys to control leave blocks displayed on the calendar
            if (CollectionUtils.isNotEmpty(lbs) && CollectionUtils.isNotEmpty(assignmentKeys)) {
                List<LeaveBlock> leaveBlocks = LmServiceLocator.getLeaveBlockService()
                        .filterLeaveBlocksForLeaveCalendar(lbs, assignmentKeys);
                leaveCalendarDay.setLeaveBlocks(leaveBlocks);
            } else {
                leaveCalendarDay.setLeaveBlocks(lbs);
            }

            if (HrServiceLocator.getHRPermissionService().canViewLeaveTabsWithNEStatus()) {
                TimesheetDocumentHeader tdh = TkServiceLocator.getTimesheetDocumentHeaderService()
                        .getDocumentHeaderForDate(principalId, leaveDate.toDateTimeAtStartOfDay());
                if (tdh != null) {
                    if (DateUtils.isSameDay(leaveDate.toDate(), tdh.getEndDate())
                            || leaveDate.isAfter(LocalDate.fromDateFields(tdh.getEndDate()))) {
                        leaveCalendarDay.setDayEditable(true);
                    }
                } else {
                    leaveCalendarDay.setDayEditable(true);
                }
            } else {
                leaveCalendarDay.setDayEditable(true);
            }
            //KPME-2560 If leave calendar document is final status, then User wont be able to add leave blocks to the calendar. 
            if (!dayEditableFlag)
                leaveCalendarDay.setDayEditable(false);

            dayNumber++;
        }
        leaveCalendarDay.setDayNumberString(currentDisplayDateTime.dayOfMonth().getAsShortText());
        leaveCalendarDay.setDateString(currentDisplayDateTime.toString(HrConstants.DT_BASIC_DATE_FORMAT));

        leaveCalendarWeek.getDays().add(leaveCalendarDay);

        if (leaveCalendarWeek.getDays().size() == DateTimeConstants.DAYS_PER_WEEK) {
            getWeeks().add(leaveCalendarWeek);
            leaveCalendarWeek = new LeaveCalendarWeek();
        }

        currentDisplayDateTime = currentDisplayDateTime.plusDays(1);
    }

    if (!leaveCalendarWeek.getDays().isEmpty()) {
        getWeeks().add(leaveCalendarWeek);
    }

    boolean isPlanningCal = LmServiceLocator.getLeaveCalendarService().isLeavePlanningCalendar(principalId,
            calendarEntry.getBeginPeriodFullDateTime().toLocalDate(),
            calendarEntry.getEndPeriodFullDateTime().toLocalDate());
    Map<String, String> earnCodes = HrServiceLocator.getEarnCodeService().getEarnCodesForDisplay(principalId,
            isPlanningCal);
    setEarnCodeList(earnCodes);
}

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

License:Educational Community License

public boolean isLeavePlanningCalendar(String principalId, LocalDate beginDate, LocalDate endDate) {
    LocalDate today = LocalDate.now();

    List<Job> jobs = HrServiceLocator.getJobService().getJobs(principalId, endDate);
    for (Job job : jobs) {
        //  Check for Leave eligibility.
        if (job.isEligibleForLeave()) {
            //  Check for Time (FLSA nonexempt) jobs. If one exists, then the Leave Calendar is always a Leave Planning Calendar
            if (job.getFlsaStatus().equalsIgnoreCase(HrConstants.FLSA_STATUS_NON_EXEMPT)) {
                return true;
            } else {
                //  If leave eligible and FLSA exempt, then report leave in the Leave Calendar. Use the date to determine Planning vs Recording Calendars.
                if (beginDate.isAfter(today)) {
                    //  future period, this is a Planning Calendar.
                    return true;
                } else {
                    //  not a future period, this is a Reporting Calendar.
                    return false;
                }/*from  www. j av  a  2s . c om*/
            }
        } else {
            //  not leave eligible
            return false;
        }
    }
    return false;
}

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

License:Educational Community License

@Override
public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) throws Exception {
    LeaveCalendarForm leaveCalendarForm = (LeaveCalendarForm) form;
    String documentId = leaveCalendarForm.getDocumentId();
    String principalId = HrContext.getTargetPrincipalId();
    CalendarEntry calendarEntry = null;//w  ww .  j  a v a 2s. c  o  m
    LeaveCalendarDocument leaveCalendarDocument = null;
    if (StringUtils.isNotBlank(documentId)) {
        leaveCalendarDocument = LmServiceLocator.getLeaveCalendarService().getLeaveCalendarDocument(documentId);

        if (leaveCalendarDocument != null) {
            calendarEntry = leaveCalendarDocument.getCalendarEntry();
        }
    } else {
        if (StringUtils.isNotBlank(leaveCalendarForm.getHrCalendarEntryId())) {
            calendarEntry = HrServiceLocator.getCalendarEntryService()
                    .getCalendarEntry(leaveCalendarForm.getHrCalendarEntryId());
        } else {
            calendarEntry = HrServiceLocator.getCalendarEntryService().getCurrentCalendarDatesForLeaveCalendar(
                    principalId, new LocalDate().toDateTimeAtStartOfDay());
        }

        if (calendarEntry != null) {
            if (LmServiceLocator.getLeaveCalendarService().shouldCreateLeaveDocument(principalId,
                    calendarEntry)) {
                leaveCalendarDocument = LmServiceLocator.getLeaveCalendarService()
                        .openLeaveCalendarDocument(principalId, calendarEntry);
            } else {
                LeaveCalendarDocumentHeader header = LmServiceLocator.getLeaveCalendarDocumentHeaderService()
                        .getDocumentHeader(principalId, calendarEntry.getBeginPeriodFullDateTime(),
                                calendarEntry.getEndPeriodFullDateTime());
                if (header != null) {
                    leaveCalendarDocument = LmServiceLocator.getLeaveCalendarService()
                            .getLeaveCalendarDocument(header.getDocumentId());
                }
            }
        }
    }

    if (calendarEntry != null) {
        leaveCalendarForm.setHrCalendarEntryId(calendarEntry.getHrCalendarEntryId());
        leaveCalendarForm.setCalendarEntry(calendarEntry);
        leaveCalendarForm.setBeginCalendarEntryDate(calendarEntry.getBeginPeriodDateTime());
        leaveCalendarForm
                .setEndCalendarEntryDate(DateUtils.addMilliseconds(calendarEntry.getEndPeriodDateTime(), -1));

        CalendarEntry previousCalendarEntry = HrServiceLocator.getCalendarEntryService()
                .getPreviousCalendarEntryByCalendarId(calendarEntry.getHrCalendarId(), calendarEntry);
        if (previousCalendarEntry != null) {
            LocalDate previousBeginDate = previousCalendarEntry.getBeginPeriodFullDateTime().toLocalDate();
            LocalDate previousEndDate = previousCalendarEntry.getEndPeriodFullDateTime().toLocalDate()
                    .minusDays(1);

            PrincipalHRAttributes principalHRAttributes = HrServiceLocator.getPrincipalHRAttributeService()
                    .getPrincipalCalendar(principalId, previousEndDate);
            if (principalHRAttributes != null) {
                LocalDate serviceDate = principalHRAttributes.getServiceLocalDate();
                if (serviceDate != null) {
                    if (previousBeginDate.isEqual(serviceDate) || previousBeginDate.isAfter(serviceDate)) {
                        leaveCalendarForm
                                .setPrevHrCalendarEntryId(previousCalendarEntry.getHrCalendarEntryId());
                    }
                } else {
                    leaveCalendarForm.setPrevHrCalendarEntryId(previousCalendarEntry.getHrCalendarEntryId());
                }
            }
        }

        int planningMonths = ActionFormUtils.getPlanningMonthsForEmployee(principalId);
        if (planningMonths != 0) {
            List<CalendarEntry> futureCalendarEntries = HrServiceLocator.getCalendarEntryService()
                    .getFutureCalendarEntries(calendarEntry.getHrCalendarId(),
                            new LocalDate().toDateTimeAtStartOfDay(), planningMonths);
            if (!futureCalendarEntries.isEmpty()) {
                CalendarEntry nextCalendarEntry = HrServiceLocator.getCalendarEntryService()
                        .getNextCalendarEntryByCalendarId(calendarEntry.getHrCalendarId(), calendarEntry);
                CalendarEntry lastFutureCalendarEntry = futureCalendarEntries
                        .get(futureCalendarEntries.size() - 1);

                if (nextCalendarEntry != null && futureCalendarEntries != null) {
                    DateTime nextCalendarEntryBeginDate = nextCalendarEntry.getBeginPeriodFullDateTime();
                    DateTime lastFutureCalendarEntryBeginDate = lastFutureCalendarEntry
                            .getBeginPeriodFullDateTime();
                    if (nextCalendarEntryBeginDate.isBefore(lastFutureCalendarEntryBeginDate)
                            || nextCalendarEntryBeginDate.isEqual(lastFutureCalendarEntryBeginDate)) {
                        leaveCalendarForm.setNextHrCalendarEntryId(nextCalendarEntry.getHrCalendarEntryId());
                    }
                }
            }
        }

        setCalendarFields(request, leaveCalendarForm);
    } else {
        EntityNamePrincipalName entityNamePrincipalName = KimApiServiceLocator.getIdentityService()
                .getDefaultNamesForPrincipalId(principalId);
        GlobalVariables.getMessageMap().putError(KRADConstants.GLOBAL_ERRORS, "error.missing.leaveCalendar",
                entityNamePrincipalName.getPrincipalName());
    }

    ActionForward actionForward = super.execute(mapping, form, request, response);

    if (calendarEntry != null) {
        List<Assignment> assignments = HrServiceLocator.getAssignmentService()
                .getAssignmentsByCalEntryForLeaveCalendar(principalId, calendarEntry);
        List<String> assignmentKeys = new ArrayList<String>();
        for (Assignment assignment : assignments) {
            assignmentKeys.add(assignment.getAssignmentKey());
        }

        if (leaveCalendarDocument != null) {
            leaveCalendarForm.setLeaveCalendarDocument(leaveCalendarDocument);
            leaveCalendarForm.setDocumentId(leaveCalendarDocument.getDocumentId());
            leaveCalendarForm.setAssignmentDescriptions(leaveCalendarDocument.getAssignmentDescriptions());
        } else {
            leaveCalendarForm.setAssignmentDescriptions(HrServiceLocator.getAssignmentService()
                    .getAssignmentDescriptionsForAssignments(assignments));
        }

        if (HrServiceLocator.getHRPermissionService().canViewLeaveTabsWithNEStatus()) {
            if (LocalDate.now().isBefore(calendarEntry.getEndPeriodFullDateTime().toLocalDate())
                    || LocalDate.now().isEqual(calendarEntry.getEndPeriodFullDateTime().toLocalDate())) {
                setDocEditable(leaveCalendarForm, leaveCalendarDocument);
            }
        } else {
            setDocEditable(leaveCalendarForm, leaveCalendarDocument);
        }

        runAccrualService(leaveCalendarForm);

        List<LeaveBlock> leaveBlocks = getLeaveBlocks(principalId, calendarEntry, leaveCalendarDocument,
                assignmentKeys);

        setLeaveBlocks(leaveCalendarForm, principalId, leaveBlocks, assignmentKeys);
        setLeaveSummary(leaveCalendarForm);
        setMessages(leaveCalendarForm, leaveBlocks);

        setBlockSubmittable(leaveCalendarForm, leaveCalendarDocument);
    }

    return actionForward;
}