Example usage for org.joda.time Weeks weeksBetween

List of usage examples for org.joda.time Weeks weeksBetween

Introduction

In this page you can find the example usage for org.joda.time Weeks weeksBetween.

Prototype

public static Weeks weeksBetween(ReadablePartial start, ReadablePartial end) 

Source Link

Document

Creates a Weeks representing the number of whole weeks between the two specified partial datetimes.

Usage

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

License:Apache License

public Integer getActualDepositPeriod(final LocalDate interestPostingUpToDate,
        final SavingsPeriodFrequencyType periodFrequencyType) {
    LocalDate depositFromDate = getExpectedFirstDepositOnDate();

    if (depositFromDate == null)
        depositFromDate = this.account.accountSubmittedOrActivationDate();

    Integer actualDepositPeriod = this.depositPeriod;
    if (depositFromDate == null || getMaturityLocalDate() == null
            || interestPostingUpToDate.isEqual(getMaturityLocalDate())) {
        return actualDepositPeriod;
    }/* w  w  w. j a va 2 s. c o  m*/

    final SavingsPeriodFrequencyType depositPeriodFrequencyType = periodFrequencyType;
    switch (depositPeriodFrequencyType) {
    case DAYS:
        actualDepositPeriod = Days.daysBetween(depositFromDate, interestPostingUpToDate).getDays();
        break;
    case WEEKS:
        actualDepositPeriod = Weeks.weeksBetween(depositFromDate, interestPostingUpToDate).getWeeks();
        break;
    case MONTHS:
        actualDepositPeriod = Months.monthsBetween(depositFromDate, interestPostingUpToDate).getMonths();
        break;
    case YEARS:
        actualDepositPeriod = Years.yearsBetween(depositFromDate, interestPostingUpToDate).getYears();
        break;
    case INVALID:
        actualDepositPeriod = this.depositPeriod;// default value
        break;
    }
    return actualDepositPeriod;
}

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

License:Apache License

public Integer depositPeriod(final LocalDate periodStartDate, final LocalDate periodEndDate,
        final SavingsPeriodFrequencyType periodFrequencyType) {
    Integer actualDepositPeriod = 0;

    switch (periodFrequencyType) {
    case DAYS://  ww  w.j  a v  a2s  . co  m
        actualDepositPeriod = Days.daysBetween(periodStartDate, periodEndDate).getDays();
        break;
    case WEEKS:
        actualDepositPeriod = Weeks.weeksBetween(periodStartDate, periodEndDate).getWeeks();
        break;
    case MONTHS:
        actualDepositPeriod = Months.monthsBetween(periodStartDate, periodEndDate).getMonths();
        break;
    case YEARS:
        actualDepositPeriod = Years.yearsBetween(periodStartDate, periodEndDate).getYears();
        break;
    case INVALID:
        actualDepositPeriod = 0;// default value
        break;
    }
    return actualDepositPeriod;
}

From source file:com.jd.survey.service.settings.SurveySettingsService.java

License:Open Source License

@Transactional(readOnly = false)
@SuppressWarnings("unchecked")
public void sendEmailReminders() {
    try {/*from   www  .  ja  va2  s. c  om*/
        int currentDayOfWeek = new DateTime().getDayOfWeek();
        int currentDayOfMonth = new DateTime().getDayOfMonth();
        DateTime todayDateTime = new DateTime();

        for (SurveyDefinition surveyDefinition : surveyDefinitionDAO.findAllInternal()) {
            if (surveyDefinition.getSendAutoReminders() && surveyDefinition.getUsers().size() > 0
                    && surveyDefinition.getStatusAsString().equals("P")) {
                Date lastSentDate = surveyDefinition.getAutoReminderLastSentDate();
                switch (surveyDefinition.getAutoRemindersFrequency()) {
                case WEEKLY:
                    int weeks;
                    if (lastSentDate != null) {
                        weeks = Weeks.weeksBetween(new DateTime(lastSentDate), todayDateTime).getWeeks();
                    }

                    else {
                        weeks = 1000;
                    }
                    if (weeks >= surveyDefinition.getAutoRemindersWeeklyOccurrence()) {
                        for (Day day : surveyDefinition.getAutoRemindersDays()) {
                            if (day.getId().equals(new Long(currentDayOfWeek))) {
                                sendEmailReminder(surveyDefinition);

                            }
                        }
                    }
                    break;
                case MONTHLY:
                    int months;
                    if (lastSentDate != null) {
                        months = Months.monthsBetween(new DateTime(lastSentDate), todayDateTime).getMonths();
                    } else {
                        months = 1000;
                    }
                    if (months >= surveyDefinition.getAutoRemindersMonthlyOccurrence()
                            && surveyDefinition.getAutoRemindersDayOfMonth().equals(currentDayOfMonth)) {
                        sendEmailReminder(surveyDefinition);
                    }
                    break;
                }
            }
        }
    } catch (RuntimeException e) {
        log.error(e.getMessage(), e);
    }
}

From source file:com.netflix.ice.basic.BasicDataManager.java

License:Apache License

private double[] getData(Interval interval, TagLists tagLists) throws ExecutionException {
    DateTime start = config.startDate;//from   ww w .  ja v  a2s .  co  m
    DateTime end = config.startDate;

    if (consolidateType == ConsolidateType.hourly) {
        start = interval.getStart().withDayOfMonth(1).withMillisOfDay(0);
        end = interval.getEnd();
    } else if (consolidateType == ConsolidateType.daily) {
        start = interval.getStart().withDayOfYear(1).withMillisOfDay(0);
        end = interval.getEnd();
    }

    int num = 0;
    if (consolidateType == ConsolidateType.hourly) {
        num = interval.toPeriod(PeriodType.hours()).getHours();
        if (interval.getStart().plusHours(num).isBefore(interval.getEnd()))
            num++;
    } else if (consolidateType == ConsolidateType.daily) {
        num = interval.toPeriod(PeriodType.days()).getDays();
        if (interval.getStart().plusDays(num).isBefore(interval.getEnd()))
            num++;
    } else if (consolidateType == ConsolidateType.weekly) {
        num = interval.toPeriod(PeriodType.weeks()).getWeeks();
        if (interval.getStart().plusWeeks(num).isBefore(interval.getEnd()))
            num++;
    } else if (consolidateType == ConsolidateType.monthly) {
        num = interval.toPeriod(PeriodType.months()).getMonths();
        if (interval.getStart().plusMonths(num).isBefore(interval.getEnd()))
            num++;
    }

    double[] result = new double[num];

    do {
        ReadOnlyData data = getReadOnlyData(start);

        int resultIndex = 0;
        int fromIndex = 0;

        if (interval.getStart().isBefore(start)) {
            if (consolidateType == ConsolidateType.hourly) {
                resultIndex = Hours.hoursBetween(interval.getStart(), start).getHours();
            } else if (consolidateType == ConsolidateType.daily) {
                resultIndex = Days.daysBetween(interval.getStart(), start).getDays();
            } else if (consolidateType == ConsolidateType.weekly) {
                resultIndex = Weeks.weeksBetween(interval.getStart(), start).getWeeks();
            } else if (consolidateType == ConsolidateType.monthly) {
                resultIndex = Months.monthsBetween(interval.getStart(), start).getMonths();
            }
        } else {
            if (consolidateType == ConsolidateType.hourly) {
                fromIndex = Hours.hoursBetween(start, interval.getStart()).getHours();
            } else if (consolidateType == ConsolidateType.daily) {
                fromIndex = Days.daysBetween(start, interval.getStart()).getDays();
            } else if (consolidateType == ConsolidateType.weekly) {
                fromIndex = Weeks.weeksBetween(start, interval.getStart()).getWeeks();
                if (start.getDayOfWeek() != interval.getStart().getDayOfWeek())
                    fromIndex++;
            } else if (consolidateType == ConsolidateType.monthly) {
                fromIndex = Months.monthsBetween(start, interval.getStart()).getMonths();
            }
        }

        List<Integer> columeIndexs = Lists.newArrayList();
        int columeIndex = 0;
        for (TagGroup tagGroup : data.getTagGroups()) {
            if (tagLists.contains(tagGroup))
                columeIndexs.add(columeIndex);
            columeIndex++;
        }
        while (resultIndex < num && fromIndex < data.getNum()) {
            double[] fromData = data.getData(fromIndex++);
            for (Integer cIndex : columeIndexs)
                result[resultIndex] += fromData[cIndex];
            resultIndex++;
        }

        if (consolidateType == ConsolidateType.hourly)
            start = start.plusMonths(1);
        else if (consolidateType == ConsolidateType.daily)
            start = start.plusYears(1);
        else
            break;
    } while (start.isBefore(end));

    return result;
}

From source file:com.netflix.ice.processor.BillingFileProcessor.java

License:Apache License

private void archiveSummary(Map<Product, ReadWriteData> dataMap, String prefix) throws Exception {

    DateTime monthDateTime = new DateTime(startMilli, DateTimeZone.UTC);

    for (Product product : dataMap.keySet()) {

        String prodName = product == null ? "all" : product.name;
        ReadWriteData data = dataMap.get(product);
        Collection<TagGroup> tagGroups = data.getTagGroups();

        // init daily, weekly and monthly
        List<Map<TagGroup, Double>> daily = Lists.newArrayList();
        List<Map<TagGroup, Double>> weekly = Lists.newArrayList();
        List<Map<TagGroup, Double>> monthly = Lists.newArrayList();

        // get last month data
        ReadWriteData lastMonthData = new DataWriter(prefix + "hourly_" + prodName + "_"
                + AwsUtils.monthDateFormat.print(monthDateTime.minusMonths(1)), true).getData();

        // aggregate to daily, weekly and monthly
        int dayOfWeek = monthDateTime.getDayOfWeek();
        int daysFromLastMonth = dayOfWeek - 1;
        int lastMonthNumHours = monthDateTime.minusMonths(1).dayOfMonth().getMaximumValue() * 24;
        for (int hour = 0 - daysFromLastMonth * 24; hour < data.getNum(); hour++) {
            if (hour < 0) {
                // handle data from last month, add to weekly
                Map<TagGroup, Double> prevData = lastMonthData.getData(lastMonthNumHours + hour);
                for (TagGroup tagGroup : tagGroups) {
                    Double v = prevData.get(tagGroup);
                    if (v != null && v != 0) {
                        addValue(weekly, 0, tagGroup, v);
                    }//  w w w.ja v  a2s.com
                }
            } else {
                // this month, add to weekly, monthly and daily
                Map<TagGroup, Double> map = data.getData(hour);

                for (TagGroup tagGroup : tagGroups) {
                    Double v = map.get(tagGroup);
                    if (v != null && v != 0) {
                        addValue(monthly, 0, tagGroup, v);
                        addValue(daily, hour / 24, tagGroup, v);
                        addValue(weekly, (hour + daysFromLastMonth * 24) / 24 / 7, tagGroup, v);
                    }
                }
            }
        }

        // archive daily
        int year = monthDateTime.getYear();
        DataWriter writer = new DataWriter(prefix + "daily_" + prodName + "_" + year, true);
        ReadWriteData dailyData = writer.getData();
        dailyData.setData(daily, monthDateTime.getDayOfYear() - 1, false);
        writer.archive();

        // archive monthly
        writer = new DataWriter(prefix + "monthly_" + prodName, true);
        ReadWriteData monthlyData = writer.getData();
        monthlyData.setData(monthly, Months.monthsBetween(config.startDate, monthDateTime).getMonths(), false);
        writer.archive();

        // archive weekly
        writer = new DataWriter(prefix + "weekly_" + prodName, true);
        ReadWriteData weeklyData = writer.getData();
        DateTime weekStart = monthDateTime.withDayOfWeek(1);
        int index;
        if (!weekStart.isAfter(config.startDate))
            index = 0;
        else
            index = Weeks.weeksBetween(config.startDate, weekStart).getWeeks()
                    + (config.startDate.dayOfWeek() == weekStart.dayOfWeek() ? 0 : 1);
        weeklyData.setData(weekly, index, true);
        writer.archive();
    }
}

From source file:com.pandits.opensource.JodaTimeUtil.java

License:Open Source License

public int spanIntervalInWeeks(Date startDate, Date endDate) {
    DateTime startDateTime = createDateTime(startDate);
    DateTime endDateTime = createDateTime(endDate);

    return Weeks.weeksBetween(startDateTime, endDateTime).getWeeks();
}

From source file:com.pfm.utils.recuringPayments.RecuringPaymentsOverviewManager.java

public static Integer getPeriodsInInterval(Integer recuringType, Date startDate, Date endDate) {
    Integer periods = 0;//ww  w .jav a 2 s  .  c  om
    DateTime start = new DateTime(startDate);
    DateTime end = new DateTime(endDate);
    if (Objects.equals(recuringType, RecurringTypes.Daily.getValue())) {
        periods = Days.daysBetween(start, end).getDays();
    }

    if (Objects.equals(recuringType, RecurringTypes.Weekly.getValue())) {
        periods = Weeks.weeksBetween(start, end).getWeeks();
    }

    if (Objects.equals(recuringType, RecurringTypes.Monthly.getValue())) {
        periods = Months.monthsBetween(start, end).getMonths();
    }

    if (Objects.equals(recuringType, RecurringTypes.Yearly.getValue())) {
        periods = Years.yearsBetween(start, end).getYears();
    }

    return periods;
}

From source file:com.ramzcalender.RWeekCalendar.java

License:Open Source License

@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
    super.onActivityCreated(savedInstanceState);

    nowView.setVisibility(View.GONE);

    /**// ww  w.  j  a v a2  s  .  co m
     * Checking for any customization values
     */

    if (getArguments().containsKey(CALENDER_BACKGROUND)) {

        mBackground.setBackgroundColor(getArguments().getInt(CALENDER_BACKGROUND));

    }

    if (getArguments().containsKey(DATE_SELECTOR_BACKGROUND)) {

        selectorDateIndicatorValue = getArguments().getString(DATE_SELECTOR_BACKGROUND);

    }

    if (getArguments().containsKey(CURRENT_DATE_BACKGROUND)) {

        currentDateIndicatorValue = getArguments().getInt(CURRENT_DATE_BACKGROUND);

    }

    if (getArguments().containsKey(CALENDER_TYPE)) {

        calenderType = getArguments().getInt(CALENDER_TYPE);
    }

    if (getArguments().containsKey(PRIMARY_BACKGROUND)) {

        monthView.setTextColor(getArguments().getInt(PRIMARY_BACKGROUND));
        primaryTextColor = getArguments().getInt(PRIMARY_BACKGROUND);

    }

    if (getArguments().containsKey(SECONDARY_BACKGROUND)) {

        nowView.setTextColor(getArguments().getInt(SECONDARY_BACKGROUND));
        sundayTv.setTextColor(getArguments().getInt(SECONDARY_BACKGROUND));
        mondayTv.setTextColor(getArguments().getInt(SECONDARY_BACKGROUND));
        tuesdayTv.setTextColor(getArguments().getInt(SECONDARY_BACKGROUND));
        wednesdayTv.setTextColor(getArguments().getInt(SECONDARY_BACKGROUND));
        thursdayTv.setTextColor(getArguments().getInt(SECONDARY_BACKGROUND));
        fridayTv.setTextColor(getArguments().getInt(SECONDARY_BACKGROUND));
        saturdayTv.setTextColor(getArguments().getInt(SECONDARY_BACKGROUND));

    }

    if (getArguments().containsKey(PACKAGENAME)) {

        PAKAGENAMEVALUE = getArguments().getString(PACKAGENAME);//its for showing the resource value from the parent package

    }

    if (getArguments().containsKey(NOW_BACKGROUND)) {

        Resources resources = getResources();
        nowView.setBackgroundResource(resources.getIdentifier(
                getArguments().getString(RWeekCalendar.NOW_BACKGROUND), "drawable", PAKAGENAMEVALUE));

    }

    //----------------------------------------------------------------------------------------------//

    /*If the selected calender is FDF Calender the resent the day names according to the starting days*/
    if (calenderType != NORMAL_CALENDER) {
        int startingDate = new LocalDateTime().dayOfWeek().get();
        if (startingDate == 1) {

            sundayTv.setText("Mon");
            mondayTv.setText("Tue");
            tuesdayTv.setText("Wed");
            wednesdayTv.setText("Thu");
            thursdayTv.setText("Fri");
            fridayTv.setText("Sat");
            saturdayTv.setText("Sun");

        } else if (startingDate == 2) {

            sundayTv.setText("Tue");
            mondayTv.setText("Wed");
            tuesdayTv.setText("Thu");
            wednesdayTv.setText("Fri");
            thursdayTv.setText("Sat");
            fridayTv.setText("Sun");
            saturdayTv.setText("Mon");

        } else if (startingDate == 3) {

            sundayTv.setText("Wed");
            mondayTv.setText("Thu");
            tuesdayTv.setText("Fri");
            wednesdayTv.setText("Sat");
            thursdayTv.setText("Sun");
            fridayTv.setText("Mon");
            saturdayTv.setText("Tue");

        } else if (startingDate == 4) {

            sundayTv.setText("Thu");
            mondayTv.setText("Fri");
            tuesdayTv.setText("Sat");
            wednesdayTv.setText("Sun");
            thursdayTv.setText("Mon");
            fridayTv.setText("Tue");
            saturdayTv.setText("Wed");

        } else if (startingDate == 5) {

            sundayTv.setText("Fri");
            mondayTv.setText("Sat");
            tuesdayTv.setText("Sun");
            wednesdayTv.setText("Mon");
            thursdayTv.setText("Tue");
            fridayTv.setText("Wed");
            saturdayTv.setText("Thu");

        } else if (startingDate == 6) {

            sundayTv.setText("Sat");
            mondayTv.setText("Sun");
            tuesdayTv.setText("Mon");
            wednesdayTv.setText("Tue");
            thursdayTv.setText("Wed");
            fridayTv.setText("Thu");
            saturdayTv.setText("Fri");

        }
    }

    /*Setting Calender Adaptor*/

    mAdaptor = new CalenderAdaptor(getActivity().getSupportFragmentManager());
    pager.setAdapter(mAdaptor);

    /*CalUtil is called*/

    CalUtil mCal = new CalUtil();
    //date calculation called according to the typr
    if (calenderType != NORMAL_CALENDER) {
        mCal.calculate(mStartDate, FDF_CALENDER);
    } else {
        mCal.calculate(mStartDate, NORMAL_CALENDER);
    }

    mStartDate = mCal.getStartDate();//sets start date from CalUtil

    //Setting the month name and selected date listener
    monthView.setText(selectedDate.monthOfYear().getAsShortText() + " "
            + selectedDate.year().getAsShortText().toUpperCase());
    calenderListener.onSelectDate(selectedDate);

    CURRENT_WEEK_POSITION = Weeks.weeksBetween(mStartDate, selectedDate).getWeeks();

    pager.setCurrentItem(CURRENT_WEEK_POSITION);
    /*Week change Listener*/

    pager.addOnPageChangeListener(new ViewPager.OnPageChangeListener() {

        @Override
        public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {

        }

        @Override
        public void onPageSelected(int weekNumber) {

            int addDays = weekNumber * 7;

            selectedDate = mStartDate.plusDays(addDays); //add 7 days to the selected date

            monthView.setText(selectedDate.monthOfYear().getAsShortText() + "-"
                    + selectedDate.year().getAsShortText().toUpperCase());

            if (weekNumber == CURRENT_WEEK_POSITION) {

                //the first week comes to view
                nowView.setVisibility(View.GONE);

            } else {

                //the first week goes from view nowView set visible for Quick return to first week

                nowView.setVisibility(View.VISIBLE);
            }

        }

        @Override
        public void onPageScrollStateChanged(int state) {

        }
    });

    /**
     * Change view to  the date of the current week
     */

    nowView.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {

            calenderListener.onSelectDate(new LocalDateTime());

            pager.setCurrentItem(CURRENT_WEEK_POSITION);

        }
    });

    /**
     * For quick selection of a date.Any picker or custom date picker can de used
     */
    monthView.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View view) {

            calenderListener.onSelectPicker();

        }
    });

}

From source file:com.ramzcalender.RWeekCalendar.java

License:Open Source License

/**
 * Set set date of the selected week//ww  w . j  av a2s.  c om
 *
 * @param calendar
 */
public void setDateWeek(Calendar calendar) {

    LocalDateTime ldt = LocalDateTime.fromCalendarFields(calendar);

    AppController.getInstance().setSelected(ldt);

    int nextPage = Weeks.weeksBetween(mStartDate, ldt).getWeeks();

    if (nextPage >= 0 && nextPage < getWeekBetweenDates(start, end)) {

        pager.setCurrentItem(nextPage);
        calenderListener.onSelectDate(ldt);
        WeekFragment fragment = (WeekFragment) pager.getAdapter().instantiateItem(pager, nextPage);
        fragment.ChangeSelector(ldt);
    }

}

From source file:com.ramzcalender.RWeekCalendar.java

License:Open Source License

public int getWeekBetweenDates(DateTime start, DateTime end) {

    int diff = Weeks.weeksBetween(start, end).getWeeks();
    diff = diff + 1;
    return diff;
}