1
# -*- Mode: perl; indent-tabs-mode: nil -*-
3
# The contents of this file are subject to the Mozilla Public
4
# License Version 1.1 (the "License"); you may not use this file
5
# except in compliance with the License. You may obtain a copy of
6
# the License at http://www.mozilla.org/MPL/
8
# Software distributed under the License is distributed on an "AS
9
# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
10
# implied. See the License for the specific language governing
11
# rights and limitations under the License.
13
# The Original Code is the Bugzilla Bug Tracking System.
15
# The Initial Developer of the Original Code is Netscape Communications
16
# Corporation. Portions created by Netscape are
17
# Copyright (C) 1998 Netscape Communications Corporation. All
20
# Contributor(s): Gervase Markham <gerv@gerv.net>
21
# Albert Ting <altlst@sonic.net>
22
# A. Karl Kornel <karl@kornel.name>
27
# This module represents a chart.
29
# Note that it is perfectly legal for the 'lines' member variable of this
30
# class (which is an array of Bugzilla::Series objects) to have empty members
31
# in it. If this is true, the 'labels' array will also have empty members at
33
package Bugzilla::Chart;
41
use List::Util qw(max);
45
my $class = ref($invocant) || $invocant;
47
# Create a ref to an empty hash and bless it
52
# Construct from a CGI object.
56
die("CGI object not passed in - invalid number of args \($#_\)($_)");
66
# The data structure is a list of lists (lines) of Series objects.
67
# There is a separate list for the labels.
69
# The URL encoding is:
70
# line0=67&line0=73&line1=81&line2=67...
71
# &label0=B+/+R+/+NEW&label1=...
72
# &select0=1&select3=1...
73
# &cumulate=1&datefrom=2002-02-03&dateto=2002-04-04&ctype=html...
74
# >=1&labelgt=Grand+Total
75
foreach my $param ($cgi->param()) {
77
if ($param =~ /^line(\d+)$/) {
78
foreach my $series_id ($cgi->param($param)) {
79
detaint_natural($series_id)
80
|| ThrowCodeError("invalid_series_id");
81
my $series = new Bugzilla::Series($series_id);
82
push(@{$self->{'lines'}[$1]}, $series) if $series;
86
# Store all the labels
87
if ($param =~ /^label(\d+)$/) {
88
$self->{'labels'}[$1] = $cgi->param($param);
92
# Store the miscellaneous metadata
93
$self->{'cumulate'} = $cgi->param('cumulate') ? 1 : 0;
94
$self->{'gt'} = $cgi->param('gt') ? 1 : 0;
95
$self->{'labelgt'} = $cgi->param('labelgt');
96
$self->{'datefrom'} = $cgi->param('datefrom');
97
$self->{'dateto'} = $cgi->param('dateto');
99
# If we are cumulating, a grand total makes no sense
100
$self->{'gt'} = 0 if $self->{'cumulate'};
102
# Make sure the dates are ones we are able to interpret
103
foreach my $date ('datefrom', 'dateto') {
104
if ($self->{$date}) {
105
$self->{$date} = str2time($self->{$date})
106
|| ThrowUserError("illegal_date", { date => $self->{$date}});
110
# datefrom can't be after dateto
111
if ($self->{'datefrom'} && $self->{'dateto'} &&
112
$self->{'datefrom'} > $self->{'dateto'})
114
ThrowUserError("misarranged_dates",
115
{'datefrom' => $cgi->param('datefrom'),
116
'dateto' => $cgi->param('dateto')});
120
# Alter Chart so that the selected series are added to it.
125
# Get the current size of the series; required for adding Grand Total later
126
my $current_size = scalar($self->getSeriesIDs());
128
# Count the number of added series
130
# Create new Series and push them on to the list of lines.
131
# Note that new lines have no label; the display template is responsible
132
# for inventing something sensible.
133
foreach my $series_id (@series_ids) {
134
my $series = new Bugzilla::Series($series_id);
136
push(@{$self->{'lines'}}, [$series]);
137
push(@{$self->{'labels'}}, "");
142
# If we are going from < 2 to >= 2 series, add the Grand Total line.
143
if (!$self->{'gt'}) {
144
if ($current_size < 2 &&
145
$current_size + $added >= 2)
152
# Alter Chart so that the selections are removed from it.
157
foreach my $line_id (@line_ids) {
158
if ($line_id == 65536) {
159
# Magic value - delete Grand Total.
163
delete($self->{'lines'}->[$line_id]);
164
delete($self->{'labels'}->[$line_id]);
169
# Alter Chart so that the selections are summed.
174
# We can't add the Grand Total to things.
175
@line_ids = grep(!/^65536$/, @line_ids);
177
# We can't add less than two things.
178
return if scalar(@line_ids) < 2;
182
my $biggestlength = 0;
184
# We rescue the Series objects of all the series involved in the sum.
185
foreach my $line_id (@line_ids) {
186
my @line = @{$self->{'lines'}->[$line_id]};
188
foreach my $series (@line) {
189
push(@series, $series);
192
# We keep the label that labels the line with the most series.
193
if (scalar(@line) > $biggestlength) {
194
$biggestlength = scalar(@line);
195
$label = $self->{'labels'}->[$line_id];
199
$self->remove(@line_ids);
201
push(@{$self->{'lines'}}, \@series);
202
push(@{$self->{'labels'}}, $label);
207
$self->{'_data'} ||= $self->readData();
208
return $self->{'_data'};
211
# Convert the Chart's data into a plottable form in $self->{'_data'}.
217
# Note: you get a bad image if getSeriesIDs returns nothing
218
# We need to handle errors better.
219
my $series_ids = join(",", $self->getSeriesIDs());
221
return [] unless $series_ids;
223
# Work out the date boundaries for our data.
224
my $dbh = Bugzilla->dbh;
226
# The date used is the one given if it's in a sensible range; otherwise,
227
# it's the earliest or latest date in the database as appropriate.
228
my $datefrom = $dbh->selectrow_array("SELECT MIN(series_date) " .
229
"FROM series_data " .
230
"WHERE series_id IN ($series_ids)");
231
$datefrom = str2time($datefrom);
233
if ($self->{'datefrom'} && $self->{'datefrom'} > $datefrom) {
234
$datefrom = $self->{'datefrom'};
237
my $dateto = $dbh->selectrow_array("SELECT MAX(series_date) " .
238
"FROM series_data " .
239
"WHERE series_id IN ($series_ids)");
240
$dateto = str2time($dateto);
242
if ($self->{'dateto'} && $self->{'dateto'} < $dateto) {
243
$dateto = $self->{'dateto'};
246
# Convert UNIX times back to a date format usable for SQL queries.
247
my $sql_from = time2str('%Y-%m-%d', $datefrom);
248
my $sql_to = time2str('%Y-%m-%d', $dateto);
250
# Prepare the query which retrieves the data for each series
251
my $query = "SELECT " . $dbh->sql_to_days('series_date') . " - " .
252
$dbh->sql_to_days('?') . ", series_value " .
253
"FROM series_data " .
254
"WHERE series_id = ? " .
255
"AND series_date >= ?";
257
$query .= " AND series_date <= ?";
260
my $sth = $dbh->prepare($query);
262
my $gt_index = $self->{'gt'} ? scalar(@{$self->{'lines'}}) : undef;
265
$maxvals[$gt_index] = 0 if $gt_index;
269
foreach my $line (@{$self->{'lines'}}) {
270
# Even if we end up with no data, we need an empty arrayref to prevent
271
# errors in the PNG-generating code
272
$data[$line_index] = [];
273
$maxvals[$line_index] = 0;
275
foreach my $series (@$line) {
277
# Get the data for this series and add it on
279
$sth->execute($sql_from, $series->{'series_id'}, $sql_from, $sql_to);
282
$sth->execute($sql_from, $series->{'series_id'}, $sql_from);
284
my $points = $sth->fetchall_arrayref();
286
foreach my $point (@$points) {
287
my ($datediff, $value) = @$point;
288
$data[$line_index][$datediff] ||= 0;
289
$data[$line_index][$datediff] += $value;
290
if ($data[$line_index][$datediff] > $maxvals[$line_index]) {
291
$maxvals[$line_index] = $data[$line_index][$datediff];
294
$datediff_total[$datediff] += $value;
296
# Add to the grand total, if we are doing that
298
$data[$gt_index][$datediff] ||= 0;
299
$data[$gt_index][$datediff] += $value;
300
if ($data[$gt_index][$datediff] > $maxvals[$gt_index]) {
301
$maxvals[$gt_index] = $data[$gt_index][$datediff];
307
# We are done with the series making up this line, go to the next one
311
# calculate maximum y value
312
if ($self->{'cumulate'}) {
313
# Make sure we do not try to take the max of an array with undef values
314
my @processed_datediff;
315
while (@datediff_total) {
316
my $datediff = shift @datediff_total;
317
push @processed_datediff, $datediff if defined($datediff);
319
$self->{'y_max_value'} = max(@processed_datediff);
322
$self->{'y_max_value'} = max(@maxvals);
324
$self->{'y_max_value'} |= 1; # For log()
326
# Align the max y value:
327
# For one- or two-digit numbers, increase y_max_value until divisible by 8
328
# For larger numbers, see the comments below to figure out what's going on
329
if ($self->{'y_max_value'} < 100) {
331
++$self->{'y_max_value'};
332
} while ($self->{'y_max_value'} % 8 != 0);
335
# First, get the # of digits in the y_max_value
336
my $num_digits = 1+int(log($self->{'y_max_value'})/log(10));
338
# We want to zero out all but the top 2 digits
339
my $mask_length = $num_digits - 2;
340
$self->{'y_max_value'} /= 10**$mask_length;
341
$self->{'y_max_value'} = int($self->{'y_max_value'});
342
$self->{'y_max_value'} *= 10**$mask_length;
344
# Add 10^$mask_length to the max value
345
# Continue to increase until it's divisible by 8 * 10^($mask_length-1)
346
# (Throwing in the -1 keeps at least the smallest digit at zero)
348
$self->{'y_max_value'} += 10**$mask_length;
349
} while ($self->{'y_max_value'} % (8*(10**($mask_length-1))) != 0);
353
# Add the x-axis labels into the data structure
354
my $date_progression = generateDateProgression($datefrom, $dateto);
355
unshift(@data, $date_progression);
358
# Add Grand Total to label list
359
push(@{$self->{'labels'}}, $self->{'labelgt'});
361
$data[$gt_index] ||= [];
367
# Flatten the data structure into a list of series_ids
372
foreach my $line (@{$self->{'lines'}}) {
373
foreach my $series (@$line) {
374
push(@series_ids, $series->{'series_id'});
381
# Class method to get the data necessary to populate the "select series"
382
# widgets on various pages.
383
sub getVisibleSeries {
386
# List of groups the user is in; use -1 to make sure it's not empty.
387
my $grouplist = join(", ", (-1, values(%{Bugzilla->user->groups})));
389
# Get all visible series
390
my $dbh = Bugzilla->dbh;
391
my $serieses = $dbh->selectall_arrayref("SELECT cc1.name, cc2.name, " .
392
"series.name, series.series_id " .
394
"INNER JOIN series_categories AS cc1 " .
395
" ON series.category = cc1.id " .
396
"INNER JOIN series_categories AS cc2 " .
397
" ON series.subcategory = cc2.id " .
398
"LEFT JOIN category_group_map AS cgm " .
399
" ON series.category = cgm.category_id " .
400
" AND cgm.group_id NOT IN($grouplist) " .
401
"WHERE creator = " . Bugzilla->user->id . " OR " .
402
" cgm.category_id IS NULL " .
403
$dbh->sql_group_by('series.series_id', 'cc1.name, cc2.name, ' .
405
foreach my $series (@$serieses) {
406
my ($cat, $subcat, $name, $series_id) = @$series;
407
$cats{$cat}{$subcat}{$name} = $series_id;
413
sub generateDateProgression {
414
my ($datefrom, $dateto) = @_;
417
$dateto = $dateto || time();
418
my $oneday = 60 * 60 * 24;
420
# When the from and to dates are converted by str2time(), you end up with
421
# a time figure representing midnight at the beginning of that day. We
422
# adjust the times by 1/3 and 2/3 of a day respectively to prevent
423
# edge conditions in time2str().
424
$datefrom += $oneday / 3;
425
$dateto += (2 * $oneday) / 3;
427
while ($datefrom < $dateto) {
428
push (@progression, time2str("%Y-%m-%d", $datefrom));
429
$datefrom += $oneday;
432
return \@progression;
438
# Make sure we've read in our data
439
my $data = $self->data;
441
require Data::Dumper;
442
print "<pre>Bugzilla::Chart object:\n";
443
print Data::Dumper::Dumper($self);
added
removed
Bugzilla/Chart.pm
