Refine search
public static void normaliseDateRangeCount(Map<RegularTimePeriod, Number> dateMap, int days, Class period, TimeZone timeZone) { // find earliest date, then move it forwards until we hit now Calendar cal = Calendar.getInstance(timeZone); cal.add(Calendar.DAY_OF_MONTH, - days); Date earliest = cal.getTime(); RegularTimePeriod cursor = RegularTimePeriod.createInstance(period, earliest, timeZone); RegularTimePeriod end = RegularTimePeriod.createInstance(period, new Date(), timeZone); //fix for JRA-11686. Prevents the loop from looping infinitely. while (cursor != null && cursor.compareTo(end) <= 0) { if (!dateMap.containsKey(cursor)) { dateMap.put(cursor, 0); } cursor = cursor.next(); cursor.peg(cal); } }
/** * @param interval * the interval to check. * @return <code>true</code> if timestamp is within the given interval, otherwise <code>false</code> * is returned. If passed interval was <code>null</code> false will be returned. * @throws IllegalArgumentException * if passed in value is <code>null</code>. */ private boolean isValueInInterval(TimeseriesValue value, RegularTimePeriod interval) { if (value == null) { throw new IllegalArgumentException("TimeseriesValue must not be null."); } return interval == null || interval.getStart().getTime() <= value.getTimestamp() && value.getTimestamp() < interval.getEnd().getTime(); }
/** * Returns a {@link java.util.Date} corresponding to the specified position * within a {@link RegularTimePeriod}. * * @param period the period. * @param position the position (<code>null</code> not permitted). * * @return A date. */ private Date calculateDateForPosition(RegularTimePeriod period, DateTickMarkPosition position) { if (position == null) { throw new IllegalArgumentException("Null 'position' argument."); } Date result = null; if (position == DateTickMarkPosition.START) { result = new Date(period.getFirstMillisecond()); } else if (position == DateTickMarkPosition.MIDDLE) { result = new Date(period.getMiddleMillisecond()); } else if (position == DateTickMarkPosition.END) { result = new Date(period.getLastMillisecond()); } return result; }
/** * Returns the millisecond closest to the middle of the time period. * * @return The middle millisecond. */ public long getMiddleMillisecond() { long m1 = getFirstMillisecond(); long m2 = getLastMillisecond(); return m1 + (m2 - m1) / 2; }
/** * Returns the x-value for a time period. * * @param period the period. * * @return The x-value. */ private long getX(RegularTimePeriod period) { switch (this.position) { case (START) : return period.getFirstMillisecond(this.workingCalendar); case (MIDDLE) : return period.getMiddleMillisecond(this.workingCalendar); case (END) : return period.getLastMillisecond(this.workingCalendar); default: return period.getMiddleMillisecond(this.workingCalendar); } }
cal.add(Calendar.DAY_OF_MONTH, -(days - 1)); Date earliest = cal.getTime(); RegularTimePeriod cursor = RegularTimePeriod.createInstance(timePeriodClass, earliest, timeZone); final RegularTimePeriod end = RegularTimePeriod.createInstance(timePeriodClass, new Date(currentTime), timeZone); while (cursor != null && cursor.compareTo(end) <= 0) long totalCount = totalCountLong == null ? 0L : totalCountLong; long cursorStart = cursor.getFirstMillisecond(); if (creationDate != null && creationDate.getTime() <= cursorStart && (resolutionDate == null || resolutionDate.getTime() > cursorStart)) long endDate = cursor.getLastMillisecond(); if (currentTime < endDate) totalCounts.put(cursor, totalCount); cursor = cursor.next(); cursor.peg(cal);
public String generateURL(XYDataset xyDataset, int row, int col) { final TimeSeriesCollection timeSeriesCollection = (TimeSeriesCollection) xyDataset; final TimeSeries timeSeries = timeSeriesCollection.getSeries(row); final TimeSeriesDataItem item = timeSeries.getDataItem(col); final RegularTimePeriod period = item.getPeriod(); final JqlQueryBuilder jqlQueryBuilder = JqlQueryBuilder.newBuilder(searchRequest.getQuery()); final Date startDate = period.getStart(); final Date endDate = new Date(period.getEnd().getTime()); jqlQueryBuilder.where().defaultAnd().addDateRangeCondition(getJqlFieldIdFor(dateField), startDate, endDate); jqlQueryBuilder.orderBy().addSortForFieldName(dateFieldId, SortOrder.DESC, true); final QueryOptimizer optimizer = new RedundantClausesQueryOptimizer(); final Query query = optimizer.optimizeQuery(jqlQueryBuilder.buildQuery()); return velocityRequestContext.getCanonicalBaseUrl() + "/issues/?" + searchService.getQueryString(remoteUser, query); } };
/** * transfer a XYModel into JFreeChart TimeSeriesCollection. */ private XYDataset XYModelToTimeDataset(XYModel model, Chart chart) { TimeZone tz = chart.getTimeZone(); if (tz == null) tz = TimeZones.getCurrent(); String p = chart.getPeriod(); if (p == null) p = Chart.MILLISECOND; Class pclass = (Class) _periodMap.get(p); if (pclass == null) { throw new UiException("Unsupported period for Time Series chart: "+p); } final TimeSeriesCollection dataset = new TimeSeriesCollection(tz); for (final Iterator it = model.getSeries().iterator(); it.hasNext();) { final Comparable series = (Comparable) it.next(); final org.jfree.data.time.TimeSeries tser = new org.jfree.data.time.TimeSeries(series); //new org.jfree.data.time.TimeSeries(series, pclass); //deprecated since JFreeChart 10.0.13 final int size = model.getDataCount(series); for(int j = 0; j < size; ++j) { final RegularTimePeriod period = RegularTimePeriod.createInstance( pclass, new Date(model.getX(series, j).longValue()), tz); tser.addOrUpdate(period, model.getY(series, j)); } dataset.addSeries(tser); } return dataset; }
double outsideLength = getTickMarkOutsideLength(); RegularTimePeriod t = createInstance(this.majorTickTimePeriodClass, this.first.getStart(), getTimeZone(), this.locale); long t0 = t.getFirstMillisecond(); Line2D inside = null; Line2D outside = null; long firstOnAxis = getFirst().getFirstMillisecond(); long lastOnAxis = getLast().getLastMillisecond() + 1; while (t0 <= lastOnAxis) { ticks.add(new NumberTick(Double.valueOf(t0), "", TextAnchor.CENTER, this.minorTickTimePeriodClass, new Date(t0), getTimeZone(), this.locale); long tt0 = tminor.getFirstMillisecond(); while (tt0 < t.getLastMillisecond() && tt0 < lastOnAxis) { double xx0 = valueToJava2D(tt0, dataArea, edge); g2.draw(outside); tminor = tminor.next(); tminor.peg(this.calendar); tt0 = tminor.getFirstMillisecond(); t = t.next(); t.peg(this.calendar); t0 = t.getFirstMillisecond();
long axisMin = this.first.getFirstMillisecond(); long axisMax = this.last.getLastMillisecond(); g2.setFont(this.labelInfo[band].getLabelFont()); g2.setPaint(this.labelInfo[band].getLabelPaint()); new Date(axisMin), this.timeZone, this.locale); RegularTimePeriod p2 = this.labelInfo[band].createInstance( new Date(axisMax), this.timeZone, this.locale); DateFormat df = this.labelInfo[band].getDateFormat(); df.setTimeZone(this.timeZone); String label1 = df.format(new Date(p1.getMiddleMillisecond())); String label2 = df.format(new Date(p2.getMiddleMillisecond())); Rectangle2D b1 = TextUtils.getTextBounds(label1, g2, g2.getFontMetrics()); long length = p1.getLastMillisecond() - p1.getFirstMillisecond(); int periods = (int) (ww / length) + 1; while (p.getFirstMillisecond() <= axisMax) { float x = (float) valueToJava2D(p.getMiddleMillisecond(), dataArea, edge); String label = df.format(new Date(p.getMiddleMillisecond())); long first = p.getFirstMillisecond(); long last = p.getLastMillisecond(); if (last > axisMax) { long nextXX = p.getFirstMillisecond(); long mid = (lastXX + nextXX) / 2;
/** * Sets the range for the axis, if requested, sends an * {@link AxisChangeEvent} to all registered listeners. As a side-effect, * the auto-range flag is set to {@code false} (optional). * * @param range the range ({@code null} not permitted). * @param turnOffAutoRange a flag that controls whether or not the auto * range is turned off. * @param notify a flag that controls whether or not listeners are * notified. */ @Override public void setRange(Range range, boolean turnOffAutoRange, boolean notify) { long upper = Math.round(range.getUpperBound()); long lower = Math.round(range.getLowerBound()); this.first = createInstance(this.autoRangeTimePeriodClass, new Date(lower), this.timeZone, this.locale); this.last = createInstance(this.autoRangeTimePeriodClass, new Date(upper), this.timeZone, this.locale); super.setRange(new Range(this.first.getFirstMillisecond(), this.last.getLastMillisecond() + 1.0), turnOffAutoRange, notify); }
/** * Returns the date/time that marks the start of the time period. This * method returns a new {@code Date} instance every time it is called. * * @return The start date/time. * * @see #getFirstMillisecond() */ @Override public Date getStart() { return new Date(getFirstMillisecond()); }
/** * Returns the date/time that marks the end of the time period. This * method returns a new {@code Date} instance every time it is called. * * @return The end date/time. * * @see #getLastMillisecond() */ @Override public Date getEnd() { return new Date(getLastMillisecond()); }
final Date releasedAfter = new Date(System.currentTimeMillis() - days * DateUtils.DAY_MILLIS); final List<ValueMarker> markers = new ArrayList<ValueMarker>(); final Class periodClass = ChartUtil.getTimePeriodClass(periodName); if (version.getReleaseDate() != null && releasedAfter.before(version.getReleaseDate())) RegularTimePeriod timePeriod = RegularTimePeriod.createInstance(periodClass, version.getReleaseDate(), RegularTimePeriod.DEFAULT_TIME_ZONE); ValueMarker valueMarker = new ValueMarker(timePeriod.getFirstMillisecond()); boolean isMinorVersion = isMinorVersion(version);
public void collect(Document d) { final Date creationDate = LuceneUtils.stringToDate(d.get(dateDocumentConstant1)); final Date otherDate = LuceneUtils.stringToDate(d.get(dateDocumentConstant2)); final RegularTimePeriod period = RegularTimePeriod.createInstance(timePeriodClass, otherDate, periodTimeZone); List<Long> values = result.get(period); if (values == null) { values = new ArrayList<Long>(); } values.add(otherDate.getTime() - creationDate.getTime()); result.put(period, values); } }
private void processCursor(RegularTimePeriod cursor, Double amountOfTimeSpent, Date resolutionDate) { double totalTime = getDouble(totalTimes, cursor); double totalCount = getDouble(totalCounts, cursor); long cursorStart = cursor.getFirstMillisecond(); long cursorEnd = cursor.getLastMillisecond(); if (amountOfTimeSpent != null && (resolutionDate == null || (resolutionDate.getTime() >= cursorStart && resolutionDate.getTime() <= cursorEnd))) { totalTime += amountOfTimeSpent.longValue(); totalCount++; } totalTimes.put(cursor, totalTime); totalCounts.put(cursor, totalCount); }
private void setDataByRow( final IPentahoResultSet data ) { // TODO Make this routine MDX friendly if ( data == null ) { noDataMessage = Messages.getInstance().getString( "CHART.USER_NO_DATA_AVAILABLE" ); //$NON-NLS-1$ return; // No data so we've got nothing to set // TODO come up with some sort of error strategy here. } Class timePeriodClass = TimeSeriesCollectionChartDefinition.getTimePeriodClass( getDomainPeriodType() ); Object[] rowData = data.next(); while ( rowData != null ) { String seriesName = (String) rowData[0]; TimeSeries wrkSeries = new TimeSeries( seriesName, timePeriodClass ); for ( int column = 1; column < rowData.length - 1; column = column + 2 ) { Date keyDate = getValidDate( rowData[column] ); TimeSeriesDataItem timeSeriesDataItem = new TimeSeriesDataItem( RegularTimePeriod.createInstance( timePeriodClass, keyDate, RegularTimePeriod.DEFAULT_TIME_ZONE ), ( (Number) rowData[column + 1] ).doubleValue() ); wrkSeries.add( timeSeriesDataItem ); } addSeries( wrkSeries ); rowData = data.next(); } if ( ( data.getRowCount() > 0 ) && ( this.getSeriesCount() <= 0 ) ) { noDataMessage = Messages.getInstance().getString( "CHART.USER_INCORRECT_DATA_FORMAT" ); //$NON-NLS-1$ } }
if(series == null) series = new TimeSeries(seriesName.toString(), getTimePeriod()); seriesNames.add(seriesName); seriesMap.put(seriesName, series); RegularTimePeriod.createInstance( getTimePeriod(), crtTimeSeries.getTimePeriod(), ); series.addOrUpdate(tp, crtTimeSeries.getValue());
public static void normaliseDateRange(TimeSeriesCollection collection, RegularTimePeriod[] range) { if (collection.getSeriesCount() == 0) return; // find earliest date, then move it forwards until we hit now RegularTimePeriod earliest = range[0]; RegularTimePeriod latest = range[1]; RegularTimePeriod cursor = earliest; for (int i = 0; i < collection.getSeriesCount(); i++) { TimeSeries series = collection.getSeries(i); while (cursor.compareTo(latest) != 1) { if (series.getValue(cursor) == null) series.add(cursor, Integer.valueOf(0)); cursor = cursor.next(); } cursor = earliest; } } }