Example usage for org.joda.time LocalDate plusWeeks

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

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. LocalDate
  6. plusWeeks

Introduction

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

Prototype

public LocalDate plusWeeks(int weeks)

Source Link

Document

Returns a copy of this date plus the specified number of weeks.

Usage

From source file:com.gst.portfolio.loanaccount.loanschedule.domain.LoanApplicationTerms.java

License:Apache License

public BigDecimal calculatePeriodsBetweenDates(final LocalDate startDate, final LocalDate endDate) {
    BigDecimal numberOfPeriods = BigDecimal.ZERO;
    switch (this.repaymentPeriodFrequencyType) {
    case DAYS:// ww w  .j  a v a2s . c  o m
        int numOfDays = Days.daysBetween(startDate, endDate).getDays();
        numberOfPeriods = BigDecimal.valueOf((double) numOfDays);
        break;
    case WEEKS:
        int numberOfWeeks = Weeks.weeksBetween(startDate, endDate).getWeeks();
        int daysLeftAfterWeeks = Days.daysBetween(startDate.plusWeeks(numberOfWeeks), endDate).getDays();
        numberOfPeriods = numberOfPeriods.add(BigDecimal.valueOf(numberOfWeeks))
                .add(BigDecimal.valueOf((double) daysLeftAfterWeeks / 7));
        break;
    case MONTHS:
        int numberOfMonths = Months.monthsBetween(startDate, endDate).getMonths();
        LocalDate startDateAfterConsideringMonths = null;
        LocalDate endDateAfterConsideringMonths = null;
        int diffDays = 0;
        if (this.loanCalendar == null) {
            startDateAfterConsideringMonths = startDate.plusMonths(numberOfMonths);
            startDateAfterConsideringMonths = CalendarUtils.adjustDate(startDateAfterConsideringMonths,
                    getSeedDate(), this.repaymentPeriodFrequencyType);
            endDateAfterConsideringMonths = startDate.plusMonths(numberOfMonths + 1);
            endDateAfterConsideringMonths = CalendarUtils.adjustDate(endDateAfterConsideringMonths,
                    getSeedDate(), this.repaymentPeriodFrequencyType);
        } else {
            LocalDate expectedStartDate = startDate;
            if (!CalendarUtils.isValidRedurringDate(loanCalendar.getRecurrence(),
                    loanCalendar.getStartDateLocalDate().minusMonths(getRepaymentEvery()), startDate)) {
                expectedStartDate = CalendarUtils.getNewRepaymentMeetingDate(loanCalendar.getRecurrence(),
                        startDate.minusMonths(getRepaymentEvery()), startDate.minusMonths(getRepaymentEvery()),
                        getRepaymentEvery(),
                        CalendarUtils
                                .getMeetingFrequencyFromPeriodFrequencyType(getLoanTermPeriodFrequencyType()),
                        this.holidayDetailDTO.getWorkingDays(), isSkipRepaymentOnFirstDayOfMonth, numberOfDays);
            }
            if (!expectedStartDate.isEqual(startDate)) {
                diffDays = Days.daysBetween(startDate, expectedStartDate).getDays();
            }
            if (numberOfMonths == 0) {
                startDateAfterConsideringMonths = expectedStartDate;
            } else {
                startDateAfterConsideringMonths = CalendarUtils.getNewRepaymentMeetingDate(
                        loanCalendar.getRecurrence(), expectedStartDate,
                        expectedStartDate.plusMonths(numberOfMonths), getRepaymentEvery(),
                        CalendarUtils
                                .getMeetingFrequencyFromPeriodFrequencyType(getLoanTermPeriodFrequencyType()),
                        this.holidayDetailDTO.getWorkingDays(), isSkipRepaymentOnFirstDayOfMonth, numberOfDays);
            }
            endDateAfterConsideringMonths = CalendarUtils.getNewRepaymentMeetingDate(
                    loanCalendar.getRecurrence(), startDateAfterConsideringMonths,
                    startDateAfterConsideringMonths.plusDays(1), getRepaymentEvery(),
                    CalendarUtils.getMeetingFrequencyFromPeriodFrequencyType(getLoanTermPeriodFrequencyType()),
                    this.holidayDetailDTO.getWorkingDays(), isSkipRepaymentOnFirstDayOfMonth, numberOfDays);
        }
        int daysLeftAfterMonths = Days.daysBetween(startDateAfterConsideringMonths, endDate).getDays()
                + diffDays;
        int daysInPeriodAfterMonths = Days
                .daysBetween(startDateAfterConsideringMonths, endDateAfterConsideringMonths).getDays();
        numberOfPeriods = numberOfPeriods.add(BigDecimal.valueOf(numberOfMonths))
                .add(BigDecimal.valueOf((double) daysLeftAfterMonths / daysInPeriodAfterMonths));
        break;
    case YEARS:
        int numberOfYears = Years.yearsBetween(startDate, endDate).getYears();
        LocalDate startDateAfterConsideringYears = startDate.plusYears(numberOfYears);
        LocalDate endDateAfterConsideringYears = startDate.plusYears(numberOfYears + 1);
        int daysLeftAfterYears = Days.daysBetween(startDateAfterConsideringYears, endDate).getDays();
        int daysInPeriodAfterYears = Days
                .daysBetween(startDateAfterConsideringYears, endDateAfterConsideringYears).getDays();
        numberOfPeriods = numberOfPeriods.add(BigDecimal.valueOf(numberOfYears))
                .add(BigDecimal.valueOf((double) daysLeftAfterYears / daysInPeriodAfterYears));
        break;
    default:
        break;
    }
    return numberOfPeriods;
}

From source file:com.gst.portfolio.loanaccount.loanschedule.service.LoanScheduleAssembler.java

License:Apache License

private LocalDate deriveFirstRepaymentDate(final AccountType loanType, final Integer repaymentEvery,
        final LocalDate expectedDisbursementDate, final PeriodFrequencyType repaymentPeriodFrequencyType,
        final Integer minimumDaysBetweenDisbursalAndFirstRepayment, final Calendar calendar) {

    LocalDate derivedFirstRepayment = null;

    final LocalDate dateBasedOnMinimumDaysBetweenDisbursalAndFirstRepayment = expectedDisbursementDate
            .plusDays(minimumDaysBetweenDisbursalAndFirstRepayment);

    if (calendar != null) {

        final LocalDate refernceDateForCalculatingFirstRepaymentDate = expectedDisbursementDate;
        derivedFirstRepayment = deriveFirstRepaymentDateForLoans(repaymentEvery, expectedDisbursementDate,
                refernceDateForCalculatingFirstRepaymentDate, repaymentPeriodFrequencyType,
                minimumDaysBetweenDisbursalAndFirstRepayment, calendar);

    } /*** Individual or group account, or JLG not linked to a meeting ***/
    else {//from  w  ww . j  a  va  2 s.c om
        LocalDate dateBasedOnRepaymentFrequency;
        // Derive the first repayment date as greater date among
        // (disbursement date + plus frequency) or
        // (disbursement date + minimum between disbursal and first
        // repayment )
        if (repaymentPeriodFrequencyType.isDaily()) {
            dateBasedOnRepaymentFrequency = expectedDisbursementDate.plusDays(repaymentEvery);
        } else if (repaymentPeriodFrequencyType.isWeekly()) {
            dateBasedOnRepaymentFrequency = expectedDisbursementDate.plusWeeks(repaymentEvery);
        } else if (repaymentPeriodFrequencyType.isMonthly()) {
            dateBasedOnRepaymentFrequency = expectedDisbursementDate.plusMonths(repaymentEvery);
        } /** yearly loan **/
        else {
            dateBasedOnRepaymentFrequency = expectedDisbursementDate.plusYears(repaymentEvery);
        }
        derivedFirstRepayment = dateBasedOnRepaymentFrequency.isAfter(
                dateBasedOnMinimumDaysBetweenDisbursalAndFirstRepayment) ? dateBasedOnRepaymentFrequency
                        : dateBasedOnMinimumDaysBetweenDisbursalAndFirstRepayment;
    }

    return derivedFirstRepayment;
}

From source file:com.gst.portfolio.savings.DepositAccountUtils.java

License:Apache License

public static LocalDate calculateNextDepositDate(final LocalDate lastDepositDate,
        final PeriodFrequencyType frequency, final int recurringEvery) {
    LocalDate nextDepositDate = lastDepositDate;

    switch (frequency) {
    case DAYS:// w  ww .  j  a v a2  s.c o m
        nextDepositDate = lastDepositDate.plusDays(recurringEvery);
        break;
    case WEEKS:
        nextDepositDate = lastDepositDate.plusWeeks(recurringEvery);
        break;
    case MONTHS:
        nextDepositDate = lastDepositDate.plusMonths(recurringEvery);
        break;
    case YEARS:
        nextDepositDate = lastDepositDate.plusYears(recurringEvery);
        break;
    case INVALID:
        break;
    }
    return nextDepositDate;
}

From source file:com.gst.portfolio.savings.domain.FixedDepositAccount.java

License:Apache License

public LocalDate calculateMaturityDate() {

    final LocalDate startDate = accountSubmittedOrActivationDate();
    LocalDate maturityDate = null;
    final Integer depositPeriod = this.accountTermAndPreClosure.depositPeriod();
    switch (this.accountTermAndPreClosure.depositPeriodFrequencyType()) {
    case DAYS:/* w  ww  . ja v a  2s.com*/
        maturityDate = startDate.plusDays(depositPeriod);
        break;
    case WEEKS:
        maturityDate = startDate.plusWeeks(depositPeriod);
        break;
    case MONTHS:
        maturityDate = startDate.plusMonths(depositPeriod);
        break;
    case YEARS:
        maturityDate = startDate.plusYears(depositPeriod);
        break;
    case INVALID:
        break;
    }

    return maturityDate;
}

From source file:com.gst.portfolio.savings.domain.RecurringDepositAccount.java

License:Apache License

public LocalDate calculateMaturityDate() {

    final LocalDate startDate = depositStartDate();
    LocalDate maturityDate = null;
    final Integer depositPeriod = this.accountTermAndPreClosure.depositPeriod();
    if (depositPeriod == null) {
        return maturityDate;
    }//from   w ww .  ja v a 2 s . c  o m
    switch (this.accountTermAndPreClosure.depositPeriodFrequencyType()) {
    case DAYS:
        maturityDate = startDate.plusDays(depositPeriod);
        break;
    case WEEKS:
        maturityDate = startDate.plusWeeks(depositPeriod);
        break;
    case MONTHS:
        maturityDate = startDate.plusMonths(depositPeriod);
        break;
    case YEARS:
        maturityDate = startDate.plusYears(depositPeriod);
        break;
    case INVALID:
        break;
    }

    return maturityDate;
}

From source file:com.gst.portfolio.savings.domain.SavingsAccount.java

License:Apache License

private Date calculateDateAccountIsLockedUntil(final LocalDate activationLocalDate) {

    Date lockedInUntilLocalDate = null;
    final PeriodFrequencyType lockinPeriodFrequencyType = PeriodFrequencyType
            .fromInt(this.lockinPeriodFrequencyType);
    switch (lockinPeriodFrequencyType) {
    case INVALID:
        break;/*from   w ww .j a v  a2  s .  com*/
    case DAYS:
        lockedInUntilLocalDate = activationLocalDate.plusDays(this.lockinPeriodFrequency).toDate();
        break;
    case WEEKS:
        lockedInUntilLocalDate = activationLocalDate.plusWeeks(this.lockinPeriodFrequency).toDate();
        break;
    case MONTHS:
        lockedInUntilLocalDate = activationLocalDate.plusMonths(this.lockinPeriodFrequency).toDate();
        break;
    case YEARS:
        lockedInUntilLocalDate = activationLocalDate.plusYears(this.lockinPeriodFrequency).toDate();
        break;
    }

    return lockedInUntilLocalDate;
}

From source file:com.gst.portfolio.savings.domain.SavingsAccountCharge.java

License:Apache License

private LocalDate calculateNextDueDate(final LocalDate date) {
    LocalDate nextDueLocalDate = null;
    if (isAnnualFee()) {
        nextDueLocalDate = date.withMonthOfYear(this.feeOnMonth).plusYears(1);
        nextDueLocalDate = setDayOfMonth(nextDueLocalDate);
    } else if (isMonthlyFee()) {
        nextDueLocalDate = date.plusMonths(this.feeInterval);
        nextDueLocalDate = setDayOfMonth(nextDueLocalDate);
    } else if (isWeeklyFee()) {
        nextDueLocalDate = date.plusWeeks(this.feeInterval);
        nextDueLocalDate = setDayOfWeek(nextDueLocalDate);
    }/*ww w . ja  v  a2  s.  com*/
    return nextDueLocalDate;
}

From source file:com.gst.portfolio.shareaccounts.serialization.ShareAccountDataSerializer.java

License:Apache License

private LocalDate deriveLockinPeriodDuration(final Integer lockinPeriod, final PeriodFrequencyType periodType,
        LocalDate purchaseDate) {
    LocalDate lockinDate = purchaseDate;
    if (periodType != null) {
        switch (periodType) {
        case INVALID: //It never comes in to this state.
            break;
        case DAYS:
            lockinDate = purchaseDate.plusDays(lockinPeriod);
            break;
        case WEEKS:
            lockinDate = purchaseDate.plusWeeks(lockinPeriod);
            break;
        case MONTHS:
            lockinDate = purchaseDate.plusMonths(lockinPeriod);
            break;
        case YEARS:
            lockinDate = purchaseDate.plusYears(lockinPeriod);
            break;
        }//from   w w  w  .  j  av a2 s.com
    }
    return lockinDate;
}

From source file:com.mars.test.jodatime.Mars_App.java

public static void main(String[] args) {
    // LocalDate  , TimeZone
    LocalDate dt = new LocalDate();

    // 1.?1~31//  w w w  .j a  v  a 2  s  .c  o  m
    log.info("1.?" + dt.withDayOfMonth(1).toString(pattern) + " ~ "
            + dt.dayOfMonth().withMaximumValue().toString(pattern));

    // 2.?26~25(????)
    log.info("2.?" + dt.minusMonths(1).withDayOfMonth(26).toString(pattern) + " ~ "
            + dt.withDayOfMonth(25).toString(pattern));

    // 3.???
    LocalDate date2 = dt.withDayOfMonth(5);
    if (date2.getDayOfWeek() == DateTimeConstants.SATURDAY
            || date2.getDayOfWeek() == DateTimeConstants.SUNDAY) {
        date2 = date2.plusWeeks(1).withDayOfWeek(1);
    }
    log.info("3." + date2.toString(pattern));

    LocalDate date3 = dt.plusMonths(1).withDayOfMonth(5);
    if (date3.getDayOfWeek() >= 6) {
        date3 = date3.plusWeeks(1).withDayOfWeek(1);
    }
    log.info("4.2014/7" + date3.toString(pattern));

}

From source file:com.planyourexchange.fragments.result.ResultCalculations.java

License:Open Source License

public void setNumberOfWeeks(Integer numberOfWeeks) {
    this.numberOfWeeks = new BigDecimal(numberOfWeeks);
    LocalDate localDate = LocalDate.now();
    Months months = Months.monthsBetween(localDate, localDate.plusWeeks(numberOfWeeks));
    this.months = new BigDecimal(months.getMonths());
}