summarize_time.cgi 11.8 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
#!/usr/bin/perl -wT
# -*- Mode: perl; indent-tabs-mode: nil -*-
#
# The contents of this file are subject to the Mozilla Public
# License Version 1.1 (the "License"); you may not use this file
# except in compliance with the License. You may obtain a copy of
# the License at http://www.mozilla.org/MPL/
#
# Software distributed under the License is distributed on an "AS
# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
# implied. See the License for the specific language governing
# rights and limitations under the License.
#
# The Original Code is the Bugzilla Bug Tracking System.
#
# Contributor(s): Christian Reis <kiko@async.com.br>
#                 Shane H. W. Travis <travis@sedsystems.ca>
18 19
#                 Frédéric Buclin <LpSolit@gmail.com>

20 21
use strict;

22
use lib qw(. lib);
23 24 25

use Date::Parse;         # strptime

26
use Bugzilla;
27
use Bugzilla::Constants; # LOGIN_*
28 29
use Bugzilla::Bug;       # EmitDependList
use Bugzilla::Util;      # trim
30
use Bugzilla::Error;
31 32 33 34 35

#
# Date handling
#

36
sub date_adjust_down {
37 38 39
   
    my ($year, $month, $day) = @_;

40 41 42 43 44 45 46 47 48
    if ($day == 0) {
        $month -= 1;
        $day = 31;
        # Proper day adjustment is done later.

        if ($month == 0) {
            $year -= 1;
            $month = 12;
        }
49 50
    }

51 52
    if (($month == 2) && ($day > 28)) {
        if ($year % 4 == 0 && $year % 100 != 0) {
53 54 55 56 57 58 59 60 61 62 63 64 65 66
            $day = 29;
        } else {
            $day = 28;
        }
    }

    if (($month == 4 || $month == 6 || $month == 9 || $month == 11) &&
        ($day == 31) ) 
    {
        $day = 30;
    }
    return ($year, $month, $day);
}

67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
sub date_adjust_up {
    my ($year, $month, $day) = @_;

    if ($day > 31) {
        $month += 1;
        $day    = 1;

        if ($month == 13) {
            $month = 1;
            $year += 1;
        }
    }

    if ($month == 2 && $day > 28) {
        if ($year % 4 != 0 || $year % 100 == 0 || $day > 29) {
            $month = 3;
            $day = 1;
        }
    }

    if (($month == 4 || $month == 6 || $month == 9 || $month == 11) &&
        ($day == 31) )
    {
        $month += 1; 
        $day    = 1;
    }

    return ($year, $month, $day);
}

97 98 99 100 101 102 103 104 105
sub split_by_month {
    # Takes start and end dates and splits them into a list of
    # monthly-spaced 2-lists of dates.
    my ($start_date, $end_date) = @_;

    # We assume at this point that the dates are provided and sane
    my (undef, undef, undef, $sd, $sm, $sy, undef) = strptime($start_date);
    my (undef, undef, undef, $ed, $em, $ey, undef) = strptime($end_date);

106 107
    # Find out how many months fit between the two dates so we know
    # how many times we loop.
108 109
    my $yd = $ey - $sy;
    my $md = 12 * $yd + $em - $sm;
110 111 112 113
    # If the end day is smaller than the start day, last interval is not a whole month.
    if ($sd > $ed) {
        $md -= 1;
    }
114 115 116 117 118 119

    my (@months, $sub_start, $sub_end);
    # This +1 and +1900 are a result of strptime's bizarre semantics
    my $year = $sy + 1900;
    my $month = $sm + 1;

120
    # Keep the original date, when the date will be changed in the adjust_date.
121
    my $sd_tmp = $sd;
122 123 124 125
    my $month_tmp = $month;
    my $year_tmp = $year;

    # This section handles only the whole months.
126
    for (my $i=0; $i < $md; $i++) {
127 128 129 130 131 132 133 134 135 136 137
        # Start of interval is adjusted up: 31.2. -> 1.3.
        ($year_tmp, $month_tmp, $sd_tmp) = date_adjust_up($year, $month, $sd);
        $sub_start = sprintf("%04d-%02d-%02d", $year_tmp, $month_tmp, $sd_tmp); 
        $month += 1;
        if ($month == 13) {
            $month = 1;
            $year += 1;
        }
        # End of interval is adjusted down: 31.2 -> 28.2.
        ($year_tmp, $month_tmp, $sd_tmp) = date_adjust_down($year, $month, $sd - 1);
        $sub_end = sprintf("%04d-%02d-%02d", $year_tmp, $month_tmp, $sd_tmp);
138 139 140
        push @months, [$sub_start, $sub_end];
    }
    
141 142 143 144 145 146
    # This section handles the last (unfinished) month. 
    $sub_end = sprintf("%04d-%02d-%02d", $ey + 1900, $em + 1, $ed);
    ($year_tmp, $month_tmp, $sd_tmp) = date_adjust_up($year, $month, $sd);
    $sub_start = sprintf("%04d-%02d-%02d", $year_tmp, $month_tmp, $sd_tmp);
    push @months, [$sub_start, $sub_end];

147 148 149 150 151
    return @months;
}

sub sqlize_dates {
    my ($start_date, $end_date) = @_;
152
    my $date_bits = "";
153 154 155 156 157 158 159 160 161
    my @date_values;
    if ($start_date) {
        # we've checked, trick_taint is fine
        trick_taint($start_date);
        $date_bits = " AND longdescs.bug_when > ?";
        push @date_values, $start_date;
    } 
    if ($end_date) {
        # we need to add one day to end_date to catch stuff done today
162
        # do not forget to adjust date if it was the last day of month
163
        my (undef, undef, undef, $ed, $em, $ey, undef) = strptime($end_date);
164 165
        ($ey, $em, $ed) = date_adjust_up($ey+1900, $em+1, $ed+1);
        $end_date = sprintf("%04d-%02d-%02d", $ey, $em, $ed);
166 167 168 169 170 171 172

        $date_bits .= " AND longdescs.bug_when < ?"; 
        push @date_values, $end_date;
    }
    return ($date_bits, \@date_values);
}

173 174 175 176
# Return all blockers of the current bug, recursively.
sub get_blocker_ids {
    my ($bug_id, $unique) = @_;
    $unique ||= {$bug_id => 1};
177
    my $deps = Bugzilla::Bug::EmitDependList("blocked", "dependson", $bug_id);
178 179 180
    my @unseen = grep { !$unique->{$_}++ } @$deps;
    foreach $bug_id (@unseen) {
        get_blocker_ids($bug_id, $unique);
181
    }
182
    return keys %$unique;
183 184
}

185 186 187 188 189 190
# Return a hashref whose key is chosen by the user (bug ID or commenter)
# and value is a hash of the form {bug ID, commenter, time spent}.
# So you can either view it as the time spent by commenters on each bug
# or the time spent in bugs by each commenter.
sub get_list {
    my ($bugids, $start_date, $end_date, $keyname) = @_;
191 192 193
    my $dbh = Bugzilla->dbh;

    my ($date_bits, $date_values) = sqlize_dates($start_date, $end_date);
194
    my $buglist = join(", ", @$bugids);
195

196 197 198 199 200
    # Returns the total time worked on each bug *per developer*.
    my $data = $dbh->selectall_arrayref(
            qq{SELECT SUM(work_time) AS total_time, login_name, longdescs.bug_id
                 FROM longdescs
           INNER JOIN profiles
201
                   ON longdescs.who = profiles.userid
202
           INNER JOIN bugs
203
                   ON bugs.bug_id = longdescs.bug_id
204 205 206 207 208 209 210 211
                WHERE longdescs.bug_id IN ($buglist) $date_bits } .
            $dbh->sql_group_by('longdescs.bug_id, login_name', 'longdescs.bug_when') .
           qq{ HAVING SUM(work_time) > 0}, {Slice => {}}, @$date_values);

    my %list;
    # What this loop does is to push data having the same key in an array.
    push(@{$list{ $_->{$keyname} }}, $_) foreach @$data;
    return \%list;
212 213
}

214
# Return bugs which had no activity (a.k.a work_time = 0) during the given time range.
215 216 217 218
sub get_inactive_bugs {
    my ($bugids, $start_date, $end_date) = @_;
    my $dbh = Bugzilla->dbh;
    my ($date_bits, $date_values) = sqlize_dates($start_date, $end_date);
219 220 221 222 223 224 225 226 227 228 229 230 231 232
    my $buglist = join(", ", @$bugids);

    my $bugs = $dbh->selectcol_arrayref(
        "SELECT bug_id
           FROM bugs
          WHERE bugs.bug_id IN ($buglist)
            AND NOT EXISTS (
                SELECT 1
                  FROM longdescs
                 WHERE bugs.bug_id = longdescs.bug_id
                   AND work_time > 0 $date_bits)",
         undef, @$date_values);

    return $bugs;
233 234
}

235 236 237 238 239 240 241 242 243 244 245 246 247 248
# Return 1st day of the month of the earliest activity date for a given list of bugs.
sub get_earliest_activity_date {
    my ($bugids) = @_;
    my $dbh = Bugzilla->dbh;

    my ($date) = $dbh->selectrow_array(
        'SELECT ' . $dbh->sql_date_format('MIN(bug_when)', '%Y-%m-01')
       . ' FROM longdescs
          WHERE ' . $dbh->sql_in('bug_id', $bugids)
                  . ' AND work_time > 0');

    return $date;
}

249 250 251 252 253 254 255
#
# Template code starts here
#

Bugzilla->login(LOGIN_REQUIRED);

my $cgi = Bugzilla->cgi;
256 257 258
my $user = Bugzilla->user;
my $template = Bugzilla->template;
my $vars = {};
259 260 261

Bugzilla->switch_to_shadow_db();

262
$user->is_timetracker
263 264 265
    || ThrowUserError("auth_failure", {group  => "time-tracking",
                                       action => "access",
                                       object => "timetracking_summaries"});
266 267

my @ids = split(",", $cgi->param('id'));
268
@ids = map { Bugzilla::Bug->check($_)->id } @ids;
269
scalar(@ids) || ThrowUserError('no_bugs_chosen', {action => 'view'});
270 271 272 273 274 275 276 277 278 279

my $group_by = $cgi->param('group_by') || "number";
my $monthly = $cgi->param('monthly');
my $detailed = $cgi->param('detailed');
my $do_report = $cgi->param('do_report');
my $inactive = $cgi->param('inactive');
my $do_depends = $cgi->param('do_depends');
my $ctype = scalar($cgi->param("ctype"));

my ($start_date, $end_date);
280
if ($do_report) {
281 282 283 284 285 286 287 288
    my @bugs = @ids;

    # Dependency mode requires a single bug and grabs dependents.
    if ($do_depends) {
        if (scalar(@bugs) != 1) {
            ThrowCodeError("bad_arg", { argument=>"id",
                                        function=>"summarize_time"});
        }
289 290
        @bugs = get_blocker_ids($bugs[0]);
        @bugs = grep { $user->can_see_bug($_) } @bugs;
291 292 293 294 295 296 297 298 299 300 301
    }

    $start_date = trim $cgi->param('start_date');
    $end_date = trim $cgi->param('end_date');

    # Swap dates in case the user put an end_date before the start_date
    if ($start_date && $end_date && 
        str2time($start_date) > str2time($end_date)) {
        $vars->{'warn_swap_dates'} = 1;
        ($start_date, $end_date) = ($end_date, $start_date);
    }
302 303 304 305
    foreach my $date ($start_date, $end_date) {
        next unless $date;
        validate_date($date)
          || ThrowUserError('illegal_date', {date => $date, format => 'YYYY-MM-DD'});
306
    }
307 308

    # Store dates in a session cookie so re-visiting the page
309 310 311 312 313 314 315 316 317
    # for other bugs keeps them around.
    $cgi->send_cookie(-name => 'time-summary-dates',
                      -value => join ";", ($start_date, $end_date));

    my (@parts, $part_data, @part_list);

    # Break dates apart into months if necessary; if not, we use the
    # same @parts list to allow us to use a common codepath.
    if ($monthly) {
318 319 320 321 322 323 324 325
        # Calculate the earliest activity date if the user doesn't
        # specify a start date.
        if (!$start_date) {
            $start_date = get_earliest_activity_date(\@bugs);
        }
        # Provide a default end date. Note that this differs in semantics
        # from the open-ended queries we use when start/end_date aren't
        # provided -- and clock skews will make this evident!
326
        @parts = split_by_month($start_date, 
327
                                $end_date || format_time(scalar localtime(time()), '%Y-%m-%d'));
328 329 330 331
    } else {
        @parts = ([$start_date, $end_date]);
    }

332 333
    # For each of the separate divisions, grab the relevant data.
    my $keyname = ($group_by eq 'owner') ? 'login_name' : 'bug_id';
334
    foreach my $part (@parts) {
335 336 337
        my ($sub_start, $sub_end) = @$part;
        $part_data = get_list(\@bugs, $sub_start, $sub_end, $keyname);
        push(@part_list, $part_data);
338 339
    }

340 341
    # Do we want to see inactive bugs?
    if ($inactive) {
342 343
        $vars->{'null'} = get_inactive_bugs(\@bugs, $start_date, $end_date);
    } else {
344
        $vars->{'null'} = {};
345 346
    }

347 348 349
    # Convert bug IDs to bug objects.
    @bugs = map {new Bugzilla::Bug($_)} @bugs;

350 351
    $vars->{'part_list'} = \@part_list;
    $vars->{'parts'} = \@parts;
352 353 354 355
    # We pass the list of bugs as a hashref.
    $vars->{'bugs'} = {map { $_->id => $_ } @bugs};
}
elsif ($cgi->cookie("time-summary-dates")) {
356 357 358 359 360 361 362 363 364 365 366 367 368
    ($start_date, $end_date) = split ";", $cgi->cookie('time-summary-dates');
}

$vars->{'ids'} = \@ids;
$vars->{'start_date'} = $start_date;
$vars->{'end_date'} = $end_date;
$vars->{'group_by'} = $group_by;
$vars->{'monthly'} = $monthly;
$vars->{'detailed'} = $detailed;
$vars->{'inactive'} = $inactive;
$vars->{'do_report'} = $do_report;
$vars->{'do_depends'} = $do_depends;

369
my $format = $template->get_format("bug/summarize-time", undef, $ctype);
370 371

# Get the proper content-type
372
print $cgi->header(-type=> $format->{'ctype'});
373 374
$template->process("$format->{'template'}", $vars)
  || ThrowTemplateError($template->error());