PrettyPatch.rb should be more descriptive for "git diff -M" styled patches
[WebKit-https.git] / Websites / bugs.webkit.org / summarize_time.cgi
1 #!/usr/bin/env perl -wT
2 # -*- Mode: perl; indent-tabs-mode: nil -*-
3 #
4 # The contents of this file are subject to the Mozilla Public
5 # License Version 1.1 (the "License"); you may not use this file
6 # except in compliance with the License. You may obtain a copy of
7 # the License at http://www.mozilla.org/MPL/
8 #
9 # Software distributed under the License is distributed on an "AS
10 # IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
11 # implied. See the License for the specific language governing
12 # rights and limitations under the License.
13 #
14 # The Original Code is the Bugzilla Bug Tracking System.
15 #
16 # Contributor(s): Christian Reis <kiko@async.com.br>
17 #                 Shane H. W. Travis <travis@sedsystems.ca>
18 #                 Frédéric Buclin <LpSolit@gmail.com>
19
20 use strict;
21
22 use lib qw(. lib);
23
24 use Date::Parse;         # strptime
25
26 use Bugzilla;
27 use Bugzilla::Constants; # LOGIN_*
28 use Bugzilla::Bug;       # EmitDependList
29 use Bugzilla::Util;      # trim
30 use Bugzilla::Error;
31
32 #
33 # Date handling
34 #
35
36 sub date_adjust_down {
37    
38     my ($year, $month, $day) = @_;
39
40     if ($day == 0) {
41         $month -= 1;
42         $day = 31;
43         # Proper day adjustment is done later.
44
45         if ($month == 0) {
46             $year -= 1;
47             $month = 12;
48         }
49     }
50
51     if (($month == 2) && ($day > 28)) {
52         if ($year % 4 == 0 && $year % 100 != 0) {
53             $day = 29;
54         } else {
55             $day = 28;
56         }
57     }
58
59     if (($month == 4 || $month == 6 || $month == 9 || $month == 11) &&
60         ($day == 31) ) 
61     {
62         $day = 30;
63     }
64     return ($year, $month, $day);
65 }
66
67 sub date_adjust_up {
68     my ($year, $month, $day) = @_;
69
70     if ($day > 31) {
71         $month += 1;
72         $day    = 1;
73
74         if ($month == 13) {
75             $month = 1;
76             $year += 1;
77         }
78     }
79
80     if ($month == 2 && $day > 28) {
81         if ($year % 4 != 0 || $year % 100 == 0 || $day > 29) {
82             $month = 3;
83             $day = 1;
84         }
85     }
86
87     if (($month == 4 || $month == 6 || $month == 9 || $month == 11) &&
88         ($day == 31) )
89     {
90         $month += 1; 
91         $day    = 1;
92     }
93
94     return ($year, $month, $day);
95 }
96
97 sub split_by_month {
98     # Takes start and end dates and splits them into a list of
99     # monthly-spaced 2-lists of dates.
100     my ($start_date, $end_date) = @_;
101
102     # We assume at this point that the dates are provided and sane
103     my (undef, undef, undef, $sd, $sm, $sy, undef) = strptime($start_date);
104     my (undef, undef, undef, $ed, $em, $ey, undef) = strptime($end_date);
105
106     # Find out how many months fit between the two dates so we know
107     # how many times we loop.
108     my $yd = $ey - $sy;
109     my $md = 12 * $yd + $em - $sm;
110     # If the end day is smaller than the start day, last interval is not a whole month.
111     if ($sd > $ed) {
112         $md -= 1;
113     }
114
115     my (@months, $sub_start, $sub_end);
116     # This +1 and +1900 are a result of strptime's bizarre semantics
117     my $year = $sy + 1900;
118     my $month = $sm + 1;
119
120     # Keep the original date, when the date will be changed in the adjust_date.
121     my $sd_tmp = $sd;
122     my $month_tmp = $month;
123     my $year_tmp = $year;
124
125     # This section handles only the whole months.
126     for (my $i=0; $i < $md; $i++) {
127         # Start of interval is adjusted up: 31.2. -> 1.3.
128         ($year_tmp, $month_tmp, $sd_tmp) = date_adjust_up($year, $month, $sd);
129         $sub_start = sprintf("%04d-%02d-%02d", $year_tmp, $month_tmp, $sd_tmp); 
130         $month += 1;
131         if ($month == 13) {
132             $month = 1;
133             $year += 1;
134         }
135         # End of interval is adjusted down: 31.2 -> 28.2.
136         ($year_tmp, $month_tmp, $sd_tmp) = date_adjust_down($year, $month, $sd - 1);
137         $sub_end = sprintf("%04d-%02d-%02d", $year_tmp, $month_tmp, $sd_tmp);
138         push @months, [$sub_start, $sub_end];
139     }
140     
141     # This section handles the last (unfinished) month. 
142     $sub_end = sprintf("%04d-%02d-%02d", $ey + 1900, $em + 1, $ed);
143     ($year_tmp, $month_tmp, $sd_tmp) = date_adjust_up($year, $month, $sd);
144     $sub_start = sprintf("%04d-%02d-%02d", $year_tmp, $month_tmp, $sd_tmp);
145     push @months, [$sub_start, $sub_end];
146
147     return @months;
148 }
149
150 sub sqlize_dates {
151     my ($start_date, $end_date) = @_;
152     my $date_bits = "";
153     my @date_values;
154     if ($start_date) {
155         # we've checked, trick_taint is fine
156         trick_taint($start_date);
157         $date_bits = " AND longdescs.bug_when > ?";
158         push @date_values, $start_date;
159     } 
160     if ($end_date) {
161         # 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         ($ey, $em, $ed) = date_adjust_up($ey+1900, $em+1, $ed+1);
165         $end_date = sprintf("%04d-%02d-%02d", $ey, $em, $ed);
166
167         $date_bits .= " AND longdescs.bug_when < ?"; 
168         push @date_values, $end_date;
169     }
170     return ($date_bits, \@date_values);
171 }
172
173 # Return all blockers of the current bug, recursively.
174 sub get_blocker_ids {
175     my ($bug_id, $unique) = @_;
176     $unique ||= {$bug_id => 1};
177     my $deps = Bugzilla::Bug::EmitDependList("blocked", "dependson", $bug_id);
178     my @unseen = grep { !$unique->{$_}++ } @$deps;
179     foreach $bug_id (@unseen) {
180         get_blocker_ids($bug_id, $unique);
181     }
182     return keys %$unique;
183 }
184
185 # Return a hashref whose key is chosen by the user (bug ID or commenter)
186 # and value is a hash of the form {bug ID, commenter, time spent}.
187 # So you can either view it as the time spent by commenters on each bug
188 # or the time spent in bugs by each commenter.
189 sub get_list {
190     my ($bugids, $start_date, $end_date, $keyname) = @_;
191     my $dbh = Bugzilla->dbh;
192
193     my ($date_bits, $date_values) = sqlize_dates($start_date, $end_date);
194     my $buglist = join(", ", @$bugids);
195
196     # Returns the total time worked on each bug *per developer*.
197     my $data = $dbh->selectall_arrayref(
198             qq{SELECT SUM(work_time) AS total_time, login_name, longdescs.bug_id
199                  FROM longdescs
200            INNER JOIN profiles
201                    ON longdescs.who = profiles.userid
202            INNER JOIN bugs
203                    ON bugs.bug_id = longdescs.bug_id
204                 WHERE longdescs.bug_id IN ($buglist) $date_bits } .
205             $dbh->sql_group_by('longdescs.bug_id, login_name', 'longdescs.bug_when') .
206            qq{ HAVING SUM(work_time) > 0}, {Slice => {}}, @$date_values);
207
208     my %list;
209     # What this loop does is to push data having the same key in an array.
210     push(@{$list{ $_->{$keyname} }}, $_) foreach @$data;
211     return \%list;
212 }
213
214 # Return bugs which had no activity (a.k.a work_time = 0) during the given time range.
215 sub get_inactive_bugs {
216     my ($bugids, $start_date, $end_date) = @_;
217     my $dbh = Bugzilla->dbh;
218     my ($date_bits, $date_values) = sqlize_dates($start_date, $end_date);
219     my $buglist = join(", ", @$bugids);
220
221     my $bugs = $dbh->selectcol_arrayref(
222         "SELECT bug_id
223            FROM bugs
224           WHERE bugs.bug_id IN ($buglist)
225             AND NOT EXISTS (
226                 SELECT 1
227                   FROM longdescs
228                  WHERE bugs.bug_id = longdescs.bug_id
229                    AND work_time > 0 $date_bits)",
230          undef, @$date_values);
231
232     return $bugs;
233 }
234
235 #
236 # Template code starts here
237 #
238
239 Bugzilla->login(LOGIN_REQUIRED);
240
241 my $cgi = Bugzilla->cgi;
242 my $user = Bugzilla->user;
243 my $template = Bugzilla->template;
244 my $vars = {};
245
246 Bugzilla->switch_to_shadow_db();
247
248 $user->in_group(Bugzilla->params->{"timetrackinggroup"})
249     || ThrowUserError("auth_failure", {group  => "time-tracking",
250                                        action => "access",
251                                        object => "timetracking_summaries"});
252
253 my @ids = split(",", $cgi->param('id'));
254 map { ValidateBugID($_) } @ids;
255 scalar(@ids) || ThrowUserError('no_bugs_chosen', {action => 'view'});
256
257 my $group_by = $cgi->param('group_by') || "number";
258 my $monthly = $cgi->param('monthly');
259 my $detailed = $cgi->param('detailed');
260 my $do_report = $cgi->param('do_report');
261 my $inactive = $cgi->param('inactive');
262 my $do_depends = $cgi->param('do_depends');
263 my $ctype = scalar($cgi->param("ctype"));
264
265 my ($start_date, $end_date);
266 if ($do_report) {
267     my @bugs = @ids;
268
269     # Dependency mode requires a single bug and grabs dependents.
270     if ($do_depends) {
271         if (scalar(@bugs) != 1) {
272             ThrowCodeError("bad_arg", { argument=>"id",
273                                         function=>"summarize_time"});
274         }
275         @bugs = get_blocker_ids($bugs[0]);
276         @bugs = grep { $user->can_see_bug($_) } @bugs;
277     }
278
279     $start_date = trim $cgi->param('start_date');
280     $end_date = trim $cgi->param('end_date');
281
282     # Swap dates in case the user put an end_date before the start_date
283     if ($start_date && $end_date && 
284         str2time($start_date) > str2time($end_date)) {
285         $vars->{'warn_swap_dates'} = 1;
286         ($start_date, $end_date) = ($end_date, $start_date);
287     }
288     foreach my $date ($start_date, $end_date) {
289         next unless $date;
290         validate_date($date)
291           || ThrowUserError('illegal_date', {date => $date, format => 'YYYY-MM-DD'});
292     }
293
294     # Store dates in a session cookie so re-visiting the page
295     # for other bugs keeps them around.
296     $cgi->send_cookie(-name => 'time-summary-dates',
297                       -value => join ";", ($start_date, $end_date));
298
299     my (@parts, $part_data, @part_list);
300
301     # Break dates apart into months if necessary; if not, we use the
302     # same @parts list to allow us to use a common codepath.
303     if ($monthly) {
304         # unfortunately it's not too easy to guess a start date, since
305         # it depends on what bugs we're looking at. We risk bothering
306         # the user here. XXX: perhaps run a query to see what the
307         # earliest activity in longdescs for all bugs and use that as a
308         # start date.
309         $start_date || ThrowUserError("illegal_date", {'date' => $start_date});
310         # we can, however, provide a default end date. Note that this
311         # differs in semantics from the open-ended queries we use when
312         # start/end_date aren't provided -- and clock skews will make
313         # this evident!
314         @parts = split_by_month($start_date, 
315                                 $end_date || format_time(scalar localtime(time()), '%Y-%m-%d'));
316     } else {
317         @parts = ([$start_date, $end_date]);
318     }
319
320     # For each of the separate divisions, grab the relevant data.
321     my $keyname = ($group_by eq 'owner') ? 'login_name' : 'bug_id';
322     foreach my $part (@parts) {
323         my ($sub_start, $sub_end) = @$part;
324         $part_data = get_list(\@bugs, $sub_start, $sub_end, $keyname);
325         push(@part_list, $part_data);
326     }
327
328     # Do we want to see inactive bugs?
329     if ($inactive) {
330         $vars->{'null'} = get_inactive_bugs(\@bugs, $start_date, $end_date);
331     } else {
332         $vars->{'null'} = {};
333     }
334
335     # Convert bug IDs to bug objects.
336     @bugs = map {new Bugzilla::Bug($_)} @bugs;
337
338     $vars->{'part_list'} = \@part_list;
339     $vars->{'parts'} = \@parts;
340     # We pass the list of bugs as a hashref.
341     $vars->{'bugs'} = {map { $_->id => $_ } @bugs};
342 }
343 elsif ($cgi->cookie("time-summary-dates")) {
344     ($start_date, $end_date) = split ";", $cgi->cookie('time-summary-dates');
345 }
346
347 $vars->{'ids'} = \@ids;
348 $vars->{'start_date'} = $start_date;
349 $vars->{'end_date'} = $end_date;
350 $vars->{'group_by'} = $group_by;
351 $vars->{'monthly'} = $monthly;
352 $vars->{'detailed'} = $detailed;
353 $vars->{'inactive'} = $inactive;
354 $vars->{'do_report'} = $do_report;
355 $vars->{'do_depends'} = $do_depends;
356
357 my $format = $template->get_format("bug/summarize-time", undef, $ctype);
358
359 # Get the proper content-type
360 print $cgi->header(-type=> $format->{'ctype'});
361 $template->process("$format->{'template'}", $vars)
362   || ThrowTemplateError($template->error());