Example usage for org.joda.time MutableDateTime addWeeks

List of usage examples for org.joda.time MutableDateTime addWeeks

Introduction

In this page you can find the example usage for org.joda.time MutableDateTime addWeeks.

Prototype

public void addWeeks(final int weeks) 

Source Link

Document

Add a number of weeks to the date.

Usage

From source file:controllers.api.DashboardsApiController.java

License:Open Source License

private void nextStep(String interval, MutableDateTime currentTime) {
    switch (interval) {
    case "minute":
        currentTime.addMinutes(1);//w w  w. j ava2  s  .c o  m
        break;
    case "hour":
        currentTime.addHours(1);
        break;
    case "day":
        currentTime.addDays(1);
        break;
    case "week":
        currentTime.addWeeks(1);
        break;
    case "month":
        currentTime.addMonths(1);
        break;
    case "quarter":
        currentTime.addMonths(3);
        break;
    case "year":
        currentTime.addYears(1);
        break;
    default:
        throw new IllegalArgumentException("Invalid duration specified: " + interval);
    }
}

From source file:ddf.metrics.reporting.internal.rrd4j.RrdMetricsRetriever.java

License:Open Source License

private void increment(MutableDateTime chunkStart, SUMMARY_INTERVALS summaryInterval) {
    switch (summaryInterval) {
    case minute://w ww .j  a  v a 2s .co  m
        chunkStart.addMinutes(1);
        break;
    case hour:
        chunkStart.addHours(1);
        break;
    case day:
        chunkStart.addDays(1);
        break;
    case week:
        chunkStart.addWeeks(1);
        break;
    case month:
        chunkStart.addMonths(1);
        break;
    }
}

From source file:ke.co.tawi.babblesms.server.session.SessionStatisticsFactory.java

License:Open Source License

/**
 *
 * @param accountUuid/*from  w w w  .  java 2  s  .c  om*/
 * @return session statistics
 */
public static SessionStatistics getSessionStatistics(String accountUuid) {
    int count;
    //int[] arraycount = new int[2];

    SessionStatistics stats = new SessionStatistics();

    // Get the list of all networks
    List<Network> networkList = networkDAO.getAllNetworks();
    ;

    //set the count of all incoming SMS
    stats.setAllIncomingSMSCount(countUtils.getIncomingCount(accountUuid));

    //set the count of all outgoing SMS
    stats.setAllOutgoingSMSCount(countUtils.getOutgoingLog(accountUuid));

    //set the count of all outgoing Group SMS
    //stats.setAllOutgoingSMSCount(countUtils.getOutgoingGroupLog(accountUuid));

    // Set up data for the pie charts
    for (Network network : networkList) {
        //get the count of incoming SMS according to the account and network
        count = countUtils.getIncomingCount(accountUuid, network);

        //if count is greater than zero, add the information
        if (count > 0) {
            stats.addNetworkIncomingCount(network, count);
        }

        //get the count of outgoing SMS according to the account and network
        count = countUtils.getOutgoingCount(accountUuid, network);

        //if count is greater than zero, add the information
        if (count > 0) {
            stats.addNetworkOutgoingSMSCount(network, count);
        }
    }

    // Set up data for the bar charts
    DateTime dateMidnightStart = DateTime.now().minus(Hours.hours(24 * (IncomingBarDay.DAY_COUNT)));
    DateTime dateMidnightEnd = dateMidnightStart.plus(Hours.hours(24));
    int numDays = 0;
    do {
        for (Network network : networkList) {

            //get the daily count for incoming
            count = countUtils.getIncomingCount(accountUuid, network, new Date(dateMidnightStart.getMillis()),
                    new Date(dateMidnightEnd.getMillis()));
            if (count > 0) {
                stats.addNetworkIncomingUSSDCountDay(
                        new SimpleDateFormat("MMM d").format(new Date(dateMidnightStart.getMillis())), network,
                        count);
            }
            //get the daily count for outgoing
            count = countUtils.getOutgoingCount(accountUuid, network, new Date(dateMidnightStart.getMillis()),
                    new Date(dateMidnightEnd.getMillis()));

            if (count > 0) {
                stats.addNetworkOutgoingUSSDCountDay(
                        new SimpleDateFormat("MMM d").format(new Date(dateMidnightStart.getMillis())), network,
                        count);
            }

        }
        dateMidnightStart = dateMidnightStart.plus(Hours.hours(24));
        dateMidnightEnd = dateMidnightEnd.plus(Hours.hours(24));
        numDays++;
    } while (numDays < IncomingBarDay.DAY_COUNT);

    // Set up data for the Weekly bar charts                
    int numWeeks = 0;
    MutableDateTime startwkMutableDateTime = new MutableDateTime();
    MutableDateTime endwkMutableDateTime;
    startwkMutableDateTime.setDayOfWeek(1); //get the first day of the week
    startwkMutableDateTime.setMillisOfDay(0); //get 00:00:00 time of the day

    //go back to 7 weeks
    startwkMutableDateTime.addWeeks(-7);

    do {
        // set the end date by creating a copy
        endwkMutableDateTime = new MutableDateTime(startwkMutableDateTime);
        //push it by one week
        endwkMutableDateTime.addWeeks(1);

        for (Network network : networkList) {

            //get the Weekly count for Incoming USSD
            count = countUtils.getIncomingCount(accountUuid, network,
                    new Date(startwkMutableDateTime.toDate().getTime()),
                    new Date(endwkMutableDateTime.toDate().getTime()));

            if (count > 0) {
                stats.addNetworkIncomingUSSDCountWeek(
                        new SimpleDateFormat("MMM d").format(new Date(startwkMutableDateTime.getMillis())),
                        network, count);
            }

            //get the Weekly count for Outgoing USSD
            count = countUtils.getOutgoingCount(accountUuid, network,
                    new Date(startwkMutableDateTime.toDate().getTime()),
                    new Date(endwkMutableDateTime.toDate().getTime()));
            if (count > 0) {
                stats.addNetworkOutgoingUSSDCountWeek(
                        new SimpleDateFormat("MMM d").format(new Date(startwkMutableDateTime.getMillis())),
                        network, count);
            }

        }
        // get the next week
        startwkMutableDateTime.addWeeks(1);
        numWeeks++;
    } while (numWeeks < 7);

    // Set up data for the monthly bar charts               
    int numMonths = 0;
    MutableDateTime startMutableDateTime = new MutableDateTime();
    MutableDateTime endMutableDateTime;
    startMutableDateTime.setDayOfMonth(1); //get the first day of the month
    startMutableDateTime.setMillisOfDay(0); //get 00:00:00 time of the day

    //go back to 6 months
    startMutableDateTime.addMonths(-5);

    do {
        //set the end date by creating a copy
        endMutableDateTime = new MutableDateTime(startMutableDateTime);
        //push it by one month
        endMutableDateTime.addMonths(1);
        //System.out.println("Start date: " + startMutableDateTime);
        //System.out.println("End date: " + endMutableDateTime);

        for (Network network : networkList) {
            //change to use millis
            count = countUtils.getIncomingCount(accountUuid, network,
                    new Date(startMutableDateTime.toDate().getTime()),
                    new Date(endMutableDateTime.toDate().getTime()));

            if (count > 0) {
                stats.addNetworkIncomingUSSDCountMonth(
                        new SimpleDateFormat("MMM").format(new Date(startMutableDateTime.getMillis())), network,
                        count);
            }

            //System.out.println(count);                            
        }
        //get the next month
        startMutableDateTime.addMonths(1);
        numMonths++;
    } while (numMonths < 6);

    return stats;
}

From source file:net.solarnetwork.central.dras.mock.biz.MockDRASObserverBiz.java

License:Open Source License

public MockDRASObserverBiz() {
    TimeZone tz = TimeZone.getTimeZone("Pacific/Auckland");

    uniLocation = new SolarLocation();
    uniLocation.setId(counter.decrementAndGet());
    uniLocation.setCountry("NZ");
    uniLocation.setCreated(new DateTime());
    uniLocation.setName("Mock Location");
    uniLocation.setRegion("UNI");
    uniLocation.setTimeZoneId(tz.getID());
    uniLocation.setLatitude(groupLatitude);
    uniLocation.setLongitude(groupLongitude);

    uniLocations = new LinkedHashMap<Long, SolarLocation>();
    uniLocations.put(uniLocation.getId(), uniLocation);

    uniGroups = new ArrayList<SolarNodeGroup>(numGroups);
    addGroup(new SolarNodeGroup(counter.decrementAndGet(), uniLocation.getId(), "Mock Group A"));
    addGroup(new SolarNodeGroup(counter.decrementAndGet(), uniLocation.getId(), "Mock Group B"));
    participantGroups = new ArrayList<CapabilityInformation>(numGroups);
    for (SolarNodeGroup group : uniGroups) {
        SimpleCapabilityInformation groupInfo = new SimpleCapabilityInformation();
        groupInfo.setId(group.getId());/*from www  . j a  v  a2 s  .  c o  m*/
        groupInfo.setLocation(uniLocation);
        groupInfo.setGenerationCapacityWatts(participantGenerationCapacity);
        groupInfo.setStorageCapacityWattHours(participantStorageCapacity);
        participantGroups.add(groupInfo);
    }

    uniProgramParticipants = new LinkedHashSet<Identity<Long>>(numNodes);
    participantGroupMemebers = new LinkedHashMap<Long, Set<CapabilityInformation>>(numGroups);
    for (int i = 0; i < numNodes; i++) {
        SolarNode participant = new SolarNode(counter.decrementAndGet(), createRandomLocation().getId());
        uniProgramParticipants.add(participant);
        int groupIndex = (i % numGroups);
        SimpleCapabilityInformation group = (SimpleCapabilityInformation) participantGroups.get(groupIndex);
        Set<CapabilityInformation> groupMembers = participantGroupMemebers.get(group.getId());
        if (groupMembers == null) {
            groupMembers = new LinkedHashSet<CapabilityInformation>(numNodes);
            participantGroupMemebers.put(group.getId(), groupMembers);
        }
        SimpleCapabilityInformation info = new SimpleCapabilityInformation();
        info.setId(participant.getId());
        info.setLocation(uniLocations.get(participant.getLocationId()));
        info.setGenerationCapacityWatts(participantGenerationCapacity);
        info.setStorageCapacityWattHours(participantStorageCapacity);
        groupMembers.add(info);
        group.addGenerationCapacityWatts(participantGenerationCapacity);
        group.addStorageCapacityWattHours(participantStorageCapacity);
    }
    uniProgram = new Program(counter.decrementAndGet(), "UNI Program", 1);

    MutableDateTime mdt = new MutableDateTime(2011, 1, 1, 8, 0, 0, 0, DateTimeZone.forTimeZone(tz));
    uniEvents = new ArrayList<Event>(numEvents);
    uniEventParticipants = new LinkedHashMap<Long, EventParticipants>(numEvents);
    uniEventTargets = new LinkedHashMap<Long, EventTargets>(numEvents);

    EventRule eventRule = new EventRule(counter.decrementAndGet(), EventRule.RuleKind.LOAD_AMOUNT,
            EventRule.ScheduleKind.DYNAMIC);
    addEventRule(eventRule);

    for (int i = 0; i < numEvents; i++) {
        Event event = new Event(counter.decrementAndGet(), uniProgram.getId(),
                String.format("Mock Event %d", (i + 1)), mdt.toDateTime(),
                mdt.toDateTime().plus(Period.hours(2)));

        Set<Identity<Long>> groupSet = new LinkedHashSet<Identity<Long>>(2);
        switch (i % 3) {
        case 0:
            groupSet.add(participantGroups.get(0));
            break;

        case 1:
            groupSet.add(participantGroups.get(1));
            break;

        case 2:
            groupSet.add(participantGroups.get(0));
            groupSet.add(participantGroups.get(1));
            break;
        }
        EventParticipants ep = new EventParticipants(counter.decrementAndGet(), event.getId(), null, groupSet);
        uniEventParticipants.put(event.getId(), ep);

        // give each event a load shed target of 1kW
        EventTargets et = new EventTargets(counter.decrementAndGet(), eventRule.getId(),
                new TreeSet<EventTarget>(Arrays.asList(new EventTarget(Duration.ZERO, 1000D))));

        addEvent(event, ep, et);
        mdt.addWeeks(1);
    }
}

From source file:org.codelibs.elasticsearch.common.joda.DateMathParser.java

License:Apache License

private long parseMath(String mathString, long time, boolean roundUp, DateTimeZone timeZone)
        throws ElasticsearchParseException {
    if (timeZone == null) {
        timeZone = DateTimeZone.UTC;/*from  ww  w .  j  a v a  2  s . c  om*/
    }
    MutableDateTime dateTime = new MutableDateTime(time, timeZone);
    for (int i = 0; i < mathString.length();) {
        char c = mathString.charAt(i++);
        final boolean round;
        final int sign;
        if (c == '/') {
            round = true;
            sign = 1;
        } else {
            round = false;
            if (c == '+') {
                sign = 1;
            } else if (c == '-') {
                sign = -1;
            } else {
                throw new ElasticsearchParseException("operator not supported for date math [{}]", mathString);
            }
        }

        if (i >= mathString.length()) {
            throw new ElasticsearchParseException("truncated date math [{}]", mathString);
        }

        final int num;
        if (!Character.isDigit(mathString.charAt(i))) {
            num = 1;
        } else {
            int numFrom = i;
            while (i < mathString.length() && Character.isDigit(mathString.charAt(i))) {
                i++;
            }
            if (i >= mathString.length()) {
                throw new ElasticsearchParseException("truncated date math [{}]", mathString);
            }
            num = Integer.parseInt(mathString.substring(numFrom, i));
        }
        if (round) {
            if (num != 1) {
                throw new ElasticsearchParseException("rounding `/` can only be used on single unit types [{}]",
                        mathString);
            }
        }
        char unit = mathString.charAt(i++);
        MutableDateTime.Property propertyToRound = null;
        switch (unit) {
        case 'y':
            if (round) {
                propertyToRound = dateTime.yearOfCentury();
            } else {
                dateTime.addYears(sign * num);
            }
            break;
        case 'M':
            if (round) {
                propertyToRound = dateTime.monthOfYear();
            } else {
                dateTime.addMonths(sign * num);
            }
            break;
        case 'w':
            if (round) {
                propertyToRound = dateTime.weekOfWeekyear();
            } else {
                dateTime.addWeeks(sign * num);
            }
            break;
        case 'd':
            if (round) {
                propertyToRound = dateTime.dayOfMonth();
            } else {
                dateTime.addDays(sign * num);
            }
            break;
        case 'h':
        case 'H':
            if (round) {
                propertyToRound = dateTime.hourOfDay();
            } else {
                dateTime.addHours(sign * num);
            }
            break;
        case 'm':
            if (round) {
                propertyToRound = dateTime.minuteOfHour();
            } else {
                dateTime.addMinutes(sign * num);
            }
            break;
        case 's':
            if (round) {
                propertyToRound = dateTime.secondOfMinute();
            } else {
                dateTime.addSeconds(sign * num);
            }
            break;
        default:
            throw new ElasticsearchParseException("unit [{}] not supported for date math [{}]", unit,
                    mathString);
        }
        if (propertyToRound != null) {
            if (roundUp) {
                // we want to go up to the next whole value, even if we are already on a rounded value
                propertyToRound.add(1);
                propertyToRound.roundFloor();
                dateTime.addMillis(-1); // subtract 1 millisecond to get the largest inclusive value
            } else {
                propertyToRound.roundFloor();
            }
        }
    }
    return dateTime.getMillis();
}

From source file:org.elasticsearch.common.joda.DateMathParser.java

License:Apache License

private long parseMath(String mathString, long time, boolean roundUp) throws ElasticsearchParseException {
    MutableDateTime dateTime = new MutableDateTime(time, DateTimeZone.UTC);
    try {//  w  w w .  j av  a2s  .c om
        for (int i = 0; i < mathString.length();) {
            char c = mathString.charAt(i++);
            int type;
            if (c == '/') {
                type = 0;
            } else if (c == '+') {
                type = 1;
            } else if (c == '-') {
                type = 2;
            } else {
                throw new ElasticsearchParseException(
                        "operator not supported for date math [" + mathString + "]");
            }

            int num;
            if (!Character.isDigit(mathString.charAt(i))) {
                num = 1;
            } else {
                int numFrom = i;
                while (Character.isDigit(mathString.charAt(i))) {
                    i++;
                }
                num = Integer.parseInt(mathString.substring(numFrom, i));
            }
            if (type == 0) {
                // rounding is only allowed on whole numbers
                if (num != 1) {
                    throw new ElasticsearchParseException(
                            "rounding `/` can only be used on single unit types [" + mathString + "]");
                }
            }
            char unit = mathString.charAt(i++);
            switch (unit) {
            case 'y':
                if (type == 0) {
                    if (roundUp) {
                        dateTime.yearOfCentury().roundCeiling();
                    } else {
                        dateTime.yearOfCentury().roundFloor();
                    }
                } else if (type == 1) {
                    dateTime.addYears(num);
                } else if (type == 2) {
                    dateTime.addYears(-num);
                }
                break;
            case 'M':
                if (type == 0) {
                    if (roundUp) {
                        dateTime.monthOfYear().roundCeiling();
                    } else {
                        dateTime.monthOfYear().roundFloor();
                    }
                } else if (type == 1) {
                    dateTime.addMonths(num);
                } else if (type == 2) {
                    dateTime.addMonths(-num);
                }
                break;
            case 'w':
                if (type == 0) {
                    if (roundUp) {
                        dateTime.weekOfWeekyear().roundCeiling();
                    } else {
                        dateTime.weekOfWeekyear().roundFloor();
                    }
                } else if (type == 1) {
                    dateTime.addWeeks(num);
                } else if (type == 2) {
                    dateTime.addWeeks(-num);
                }
                break;
            case 'd':
                if (type == 0) {
                    if (roundUp) {
                        dateTime.dayOfMonth().roundCeiling();
                    } else {
                        dateTime.dayOfMonth().roundFloor();
                    }
                } else if (type == 1) {
                    dateTime.addDays(num);
                } else if (type == 2) {
                    dateTime.addDays(-num);
                }
                break;
            case 'h':
            case 'H':
                if (type == 0) {
                    if (roundUp) {
                        dateTime.hourOfDay().roundCeiling();
                    } else {
                        dateTime.hourOfDay().roundFloor();
                    }
                } else if (type == 1) {
                    dateTime.addHours(num);
                } else if (type == 2) {
                    dateTime.addHours(-num);
                }
                break;
            case 'm':
                if (type == 0) {
                    if (roundUp) {
                        dateTime.minuteOfHour().roundCeiling();
                    } else {
                        dateTime.minuteOfHour().roundFloor();
                    }
                } else if (type == 1) {
                    dateTime.addMinutes(num);
                } else if (type == 2) {
                    dateTime.addMinutes(-num);
                }
                break;
            case 's':
                if (type == 0) {
                    if (roundUp) {
                        dateTime.secondOfMinute().roundCeiling();
                    } else {
                        dateTime.secondOfMinute().roundFloor();
                    }
                } else if (type == 1) {
                    dateTime.addSeconds(num);
                } else if (type == 2) {
                    dateTime.addSeconds(-num);
                }
                break;
            default:
                throw new ElasticsearchParseException(
                        "unit [" + unit + "] not supported for date math [" + mathString + "]");
            }
        }
    } catch (Exception e) {
        if (e instanceof ElasticsearchParseException) {
            throw (ElasticsearchParseException) e;
        }
        throw new ElasticsearchParseException("failed to parse date math [" + mathString + "]");
    }
    return dateTime.getMillis();
}

From source file:se.streamsource.streamflow.web.context.crystal.CrystalContext.java

License:Apache License

public TableValue motionchart() {
    final TableBuilder tableBuilder = new TableBuilder(module.valueBuilderFactory());
    tableBuilder.column("CaseType", "Case type", "string").column("Week", "Week", "string")
            .column("Variation", "Variation", "number").column("Duration", "Duration", "number")
            .column("CaseCount", "Case count", "number").column("CasetypeOwner", "Casetype owner", "string");

    final Logger logger = LoggerFactory.getLogger(getClass());
    try {//from w w w .  ja  v  a  2s . com
        final String weekFormat = "yyyy'W'ww";

        DateTime[] range = findRange();
        logger.info(
                "Full range from " + range[0].toString(weekFormat) + " to " + range[1].toString(weekFormat));

        // Find cases for each week
        Databases databases = new Databases(source.get());

        final MutableDateTime from = new MutableDateTime(range[0]).dayOfWeek().set(1);

        while (from.isBefore(range[1])) {

            final MutableDateTime minWeek = from.copy();

            databases.query(sql.getString("motionchart"), new Databases.StatementVisitor() {
                public void visit(PreparedStatement preparedStatement) throws SQLException {
                    String fromWeek = from.toString(weekFormat);

                    preparedStatement.setTimestamp(1, new Timestamp(from.toDate().getTime()));
                    from.addWeeks(1);
                    preparedStatement.setTimestamp(2, new Timestamp(from.toDate().getTime()));
                    String toWeek = from.toString(weekFormat);

                    logger.info("From " + fromWeek + " to " + toWeek);
                }
            }, new Databases.ResultSetVisitor() {
                public boolean visit(ResultSet visited) throws SQLException {
                    tableBuilder.row().cell(visited.getString("casetype"), null)
                            .cell(minWeek.toString(weekFormat), "v" + minWeek.weekOfWeekyear().get())
                            .cell(visited.getString("variationpct"), null)
                            .cell((visited.getLong("average") / (1000 * 60 * 60)) + "", null)
                            .cell(visited.getString("count"), null)
                            .cell(visited.getString("casetype_owner"), null);

                    return true;
                }
            });
        }

    } catch (SQLException e) {
        logger.warn("Could not get statistics", e);
    }

    return tableBuilder.newTable();
}