46f5597186db6b1bce30b9dd3212a4e51a51d358
[WebKit-https.git] / BugsSite / Bugzilla / BugMail.pm
1 # -*- Mode: perl; indent-tabs-mode: nil -*-
2 #
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/
7 #
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.
12 #
13 # The Original Code is the Bugzilla Bug Tracking System.
14 #
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
18 # Rights Reserved.
19 #
20 # Contributor(s): Terry Weissman <terry@mozilla.org>,
21 #                 Bryce Nesbitt <bryce-mozilla@nextbus.com>
22 #                 Dan Mosedale <dmose@mozilla.org>
23 #                 Alan Raetz <al_raetz@yahoo.com>
24 #                 Jacob Steenhagen <jake@actex.net>
25 #                 Matthew Tuck <matty@chariot.net.au>
26 #                 Bradley Baetz <bbaetz@student.usyd.edu.au>
27 #                 J. Paul Reed <preed@sigkill.com>
28 #                 Gervase Markham <gerv@gerv.net>
29 #                 Byron Jones <bugzilla@glob.com.au>
30
31 use strict;
32
33 package Bugzilla::BugMail;
34
35 use Bugzilla::Error;
36 use Bugzilla::User;
37 use Bugzilla::Constants;
38 use Bugzilla::Util;
39 use Bugzilla::Bug;
40 use Bugzilla::Classification;
41 use Bugzilla::Product;
42 use Bugzilla::Component;
43 use Bugzilla::Status;
44 use Bugzilla::Mailer;
45
46 use Date::Parse;
47 use Date::Format;
48
49 use constant FORMAT_TRIPLE => "%19s|%-28s|%-28s";
50 use constant FORMAT_3_SIZE => [19,28,28];
51 use constant FORMAT_DOUBLE => "%19s %-55s";
52 use constant FORMAT_2_SIZE => [19,55];
53
54 use constant BIT_DIRECT    => 1;
55 use constant BIT_WATCHING  => 2;
56
57 # We need these strings for the X-Bugzilla-Reasons header
58 # Note: this hash uses "," rather than "=>" to avoid auto-quoting of the LHS.
59 use constant REL_NAMES => {
60     REL_ASSIGNEE      , "AssignedTo", 
61     REL_REPORTER      , "Reporter",
62     REL_QA            , "QAcontact",
63     REL_CC            , "CC",
64     REL_VOTER         , "Voter",
65     REL_GLOBAL_WATCHER, "GlobalWatcher"
66 };
67
68 # We use this instead of format because format doesn't deal well with
69 # multi-byte languages.
70 sub multiline_sprintf {
71     my ($format, $args, $sizes) = @_;
72     my @parts;
73     my @my_sizes = @$sizes; # Copy this so we don't modify the input array.
74     foreach my $string (@$args) {
75         my $size = shift @my_sizes;
76         my @pieces = split("\n", wrap_hard($string, $size));
77         push(@parts, \@pieces);
78     }
79
80     my $formatted;
81     while (1) {
82         # Get the first item of each part.
83         my @line = map { shift @$_ } @parts;
84         # If they're all undef, we're done.
85         last if !grep { defined $_ } @line;
86         # Make any single undef item into ''
87         @line = map { defined $_ ? $_ : '' } @line;
88         # And append a formatted line
89         $formatted .= sprintf($format, @line);
90         # Remove trailing spaces, or they become lots of =20's in 
91         # quoted-printable emails.
92         $formatted =~ s/\s+$//;
93         $formatted .= "\n";
94     }
95     return $formatted;
96 }
97
98 sub three_columns {
99     return multiline_sprintf(FORMAT_TRIPLE, \@_, FORMAT_3_SIZE);
100 }
101
102 # This is a bit of a hack, basically keeping the old system()
103 # cmd line interface. Should clean this up at some point.
104 #
105 # args: bug_id, and an optional hash ref which may have keys for:
106 # changer, owner, qa, reporter, cc
107 # Optional hash contains values of people which will be forced to those
108 # roles when the email is sent.
109 # All the names are email addresses, not userids
110 # values are scalars, except for cc, which is a list
111 # This hash usually comes from the "mailrecipients" var in a template call.
112 sub Send {
113     my ($id, $forced) = (@_);
114
115     my @headerlist;
116     my %defmailhead;
117     my %fielddescription;
118
119     my $msg = "";
120
121     my $dbh = Bugzilla->dbh;
122
123     # XXX - These variables below are useless. We could use field object
124     # methods directly. But we first have to implement a cache in
125     # Bugzilla->get_fields to avoid querying the DB all the time.
126     foreach my $field (Bugzilla->get_fields({obsolete => 0})) {
127         push(@headerlist, $field->name);
128         $defmailhead{$field->name} = $field->in_new_bugmail;
129         $fielddescription{$field->name} = $field->description;
130     }
131
132     my %values = %{$dbh->selectrow_hashref(
133         'SELECT ' . join(',', editable_bug_fields()) . ', reporter,
134                 lastdiffed AS start_time, LOCALTIMESTAMP(0) AS end_time
135            FROM bugs WHERE bug_id = ?',
136         undef, $id)};
137
138     my $product = new Bugzilla::Product($values{product_id});
139     $values{product} = $product->name;
140     if (Bugzilla->params->{'useclassification'}) {
141         $values{classification} = Bugzilla::Classification->new($product->classification_id)->name;
142     }
143     my $component = new Bugzilla::Component($values{component_id});
144     $values{component} = $component->name;
145
146     my ($start, $end) = ($values{start_time}, $values{end_time});
147
148     # User IDs of people in various roles. More than one person can 'have' a 
149     # role, if the person in that role has changed, or people are watching.
150     my $reporter = $values{'reporter'};
151     my @assignees = ($values{'assigned_to'});
152     my @qa_contacts = ($values{'qa_contact'});
153
154     my $cc_users = $dbh->selectall_arrayref(
155            "SELECT cc.who, profiles.login_name
156               FROM cc
157         INNER JOIN profiles
158                 ON cc.who = profiles.userid
159              WHERE bug_id = ?",
160            undef, $id);
161
162     my (@ccs, @cc_login_names);
163     foreach my $cc_user (@$cc_users) {
164         my ($user_id, $user_login) = @$cc_user;
165         push (@ccs, $user_id);
166         push (@cc_login_names, $user_login);
167     }
168
169     # Include the people passed in as being in particular roles.
170     # This can include people who used to hold those roles.
171     # At this point, we don't care if there are duplicates in these arrays.
172     my $changer = $forced->{'changer'};
173     if ($forced->{'owner'}) {
174         push (@assignees, login_to_id($forced->{'owner'}, THROW_ERROR));
175     }
176     
177     if ($forced->{'qacontact'}) {
178         push (@qa_contacts, login_to_id($forced->{'qacontact'}, THROW_ERROR));
179     }
180     
181     if ($forced->{'cc'}) {
182         foreach my $cc (@{$forced->{'cc'}}) {
183             push(@ccs, login_to_id($cc, THROW_ERROR));
184         }
185     }
186     
187     # Convert to names, for later display
188     $values{'changer'} = $changer;
189     # If no changer is specified, then it has no name.
190     if ($changer) {
191         $values{'changername'} = Bugzilla::User->new({name => $changer})->name;
192     }
193     $values{'assigned_to'} = user_id_to_login($values{'assigned_to'});
194     $values{'reporter'} = user_id_to_login($values{'reporter'});
195     if ($values{'qa_contact'}) {
196         $values{'qa_contact'} = user_id_to_login($values{'qa_contact'});
197     }
198     $values{'cc'} = join(', ', @cc_login_names);
199     $values{'estimated_time'} = format_time_decimal($values{'estimated_time'});
200
201     if ($values{'deadline'}) {
202         $values{'deadline'} = time2str("%Y-%m-%d", str2time($values{'deadline'}));
203     }
204
205     my $dependslist = $dbh->selectcol_arrayref(
206         'SELECT dependson FROM dependencies
207          WHERE blocked = ? ORDER BY dependson',
208         undef, ($id));
209
210     $values{'dependson'} = join(",", @$dependslist);
211
212     my $blockedlist = $dbh->selectcol_arrayref(
213         'SELECT blocked FROM dependencies
214          WHERE dependson = ? ORDER BY blocked',
215         undef, ($id));
216
217     $values{'blocked'} = join(",", @$blockedlist);
218
219     my @args = ($id);
220
221     # If lastdiffed is NULL, then we don't limit the search on time.
222     my $when_restriction = '';
223     if ($start) {
224         $when_restriction = ' AND bug_when > ? AND bug_when <= ?';
225         push @args, ($start, $end);
226     }
227     
228     my $diffs = $dbh->selectall_arrayref(
229            "SELECT profiles.login_name, profiles.realname, fielddefs.description,
230                    bugs_activity.bug_when, bugs_activity.removed, 
231                    bugs_activity.added, bugs_activity.attach_id, fielddefs.name
232               FROM bugs_activity
233         INNER JOIN fielddefs
234                 ON fielddefs.id = bugs_activity.fieldid
235         INNER JOIN profiles
236                 ON profiles.userid = bugs_activity.who
237              WHERE bugs_activity.bug_id = ?
238                    $when_restriction
239           ORDER BY bugs_activity.bug_when", undef, @args);
240
241     my @new_depbugs;
242     my $difftext = "";
243     my $diffheader = "";
244     my @diffparts;
245     my $lastwho = "";
246     my $fullwho;
247     my @changedfields;
248     foreach my $ref (@$diffs) {
249         my ($who, $whoname, $what, $when, $old, $new, $attachid, $fieldname) = (@$ref);
250         my $diffpart = {};
251         if ($who ne $lastwho) {
252             $lastwho = $who;
253             $fullwho = $whoname ? "$whoname <$who>" : $who;
254             $diffheader = "\n$fullwho changed:\n\n";
255             $diffheader .= three_columns("What    ", "Removed", "Added");
256             $diffheader .= ('-' x 76) . "\n";
257         }
258         $what =~ s/^(Attachment )?/Attachment #$attachid / if $attachid;
259         if( $fieldname eq 'estimated_time' ||
260             $fieldname eq 'remaining_time' ) {
261             $old = format_time_decimal($old);
262             $new = format_time_decimal($new);
263         }
264         if ($fieldname eq 'dependson') {
265             push(@new_depbugs, grep {$_ =~ /^\d+$/} split(/[\s,]+/, $new));
266         }
267         if ($attachid) {
268             ($diffpart->{'isprivate'}) = $dbh->selectrow_array(
269                 'SELECT isprivate FROM attachments WHERE attach_id = ?',
270                 undef, ($attachid));
271         }
272         $difftext = three_columns($what, $old, $new);
273         $diffpart->{'header'} = $diffheader;
274         $diffpart->{'fieldname'} = $fieldname;
275         $diffpart->{'text'} = $difftext;
276         push(@diffparts, $diffpart);
277         push(@changedfields, $what);
278     }
279     $values{'changed_fields'} = join(' ', @changedfields);
280
281     my @depbugs;
282     my $deptext = "";
283     # Do not include data about dependent bugs when they have just been added.
284     # Completely skip checking for dependent bugs on bug creation as all
285     # dependencies bugs will just have been added.
286     if ($start) {
287         my $dep_restriction = "";
288         if (scalar @new_depbugs) {
289             $dep_restriction = "AND bugs_activity.bug_id NOT IN (" .
290                                join(", ", @new_depbugs) . ")";
291         }
292
293         my $dependency_diffs = $dbh->selectall_arrayref(
294            "SELECT bugs_activity.bug_id, bugs.short_desc, fielddefs.name, 
295                    bugs_activity.removed, bugs_activity.added
296               FROM bugs_activity
297         INNER JOIN bugs
298                 ON bugs.bug_id = bugs_activity.bug_id
299         INNER JOIN dependencies
300                 ON bugs_activity.bug_id = dependencies.dependson
301         INNER JOIN fielddefs
302                 ON fielddefs.id = bugs_activity.fieldid
303              WHERE dependencies.blocked = ?
304                AND (fielddefs.name = 'bug_status'
305                     OR fielddefs.name = 'resolution')
306                    $when_restriction
307                    $dep_restriction
308           ORDER BY bugs_activity.bug_when, bugs.bug_id", undef, @args);
309
310         my $thisdiff = "";
311         my $lastbug = "";
312         my $interestingchange = 0;
313         foreach my $dependency_diff (@$dependency_diffs) {
314             my ($depbug, $summary, $what, $old, $new) = @$dependency_diff;
315
316             if ($depbug ne $lastbug) {
317                 if ($interestingchange) {
318                     $deptext .= $thisdiff;
319                 }
320                 $lastbug = $depbug;
321                 my $urlbase = Bugzilla->params->{"urlbase"};
322                 $thisdiff =
323                   "\nBug $id depends on bug $depbug, which changed state.\n\n" .
324                   "Bug $depbug Summary: $summary\n" .
325                   "${urlbase}show_bug.cgi?id=$depbug\n\n";
326                 $thisdiff .= three_columns("What    ", "Old Value", "New Value");
327                 $thisdiff .= ('-' x 76) . "\n";
328                 $interestingchange = 0;
329             }
330             $thisdiff .= three_columns($fielddescription{$what}, $old, $new);
331             if ($what eq 'bug_status'
332                 && is_open_state($old) ne is_open_state($new))
333             {
334                 $interestingchange = 1;
335             }
336             push(@depbugs, $depbug);
337         }
338
339         if ($interestingchange) {
340             $deptext .= $thisdiff;
341         }
342         $deptext = trim($deptext);
343
344         if ($deptext) {
345             my $diffpart = {};
346             $diffpart->{'text'} = "\n" . trim("\n\n" . $deptext);
347             push(@diffparts, $diffpart);
348         }
349     }
350
351     my ($raw_comments, $anyprivate, $count) = get_comments_by_bug($id, $start, $end);
352
353     ###########################################################################
354     # Start of email filtering code
355     ###########################################################################
356     
357     # A user_id => roles hash to keep track of people.
358     my %recipients;
359     my %watching;
360     
361     # Now we work out all the people involved with this bug, and note all of
362     # the relationships in a hash. The keys are userids, the values are an
363     # array of role constants.
364     
365     # Voters
366     my $voters = $dbh->selectcol_arrayref(
367         "SELECT who FROM votes WHERE bug_id = ?", undef, ($id));
368         
369     $recipients{$_}->{+REL_VOTER} = BIT_DIRECT foreach (@$voters);
370
371     # CCs
372     $recipients{$_}->{+REL_CC} = BIT_DIRECT foreach (@ccs);
373     
374     # Reporter (there's only ever one)
375     $recipients{$reporter}->{+REL_REPORTER} = BIT_DIRECT;
376     
377     # QA Contact
378     if (Bugzilla->params->{'useqacontact'}) {
379         foreach (@qa_contacts) {
380             # QA Contact can be blank; ignore it if so.
381             $recipients{$_}->{+REL_QA} = BIT_DIRECT if $_;
382         }
383     }
384
385     # Assignee
386     $recipients{$_}->{+REL_ASSIGNEE} = BIT_DIRECT foreach (@assignees);
387
388     # The last relevant set of people are those who are being removed from 
389     # their roles in this change. We get their names out of the diffs.
390     foreach my $ref (@$diffs) {
391         my ($who, $whoname, $what, $when, $old, $new) = (@$ref);
392         if ($old) {
393             # You can't stop being the reporter, and mail isn't sent if you
394             # remove your vote.
395             # Ignore people whose user account has been deleted or renamed.
396             if ($what eq "CC") {
397                 foreach my $cc_user (split(/[\s,]+/, $old)) {
398                     my $uid = login_to_id($cc_user);
399                     $recipients{$uid}->{+REL_CC} = BIT_DIRECT if $uid;
400                 }
401             }
402             elsif ($what eq "QAContact") {
403                 my $uid = login_to_id($old);
404                 $recipients{$uid}->{+REL_QA} = BIT_DIRECT if $uid;
405             }
406             elsif ($what eq "AssignedTo") {
407                 my $uid = login_to_id($old);
408                 $recipients{$uid}->{+REL_ASSIGNEE} = BIT_DIRECT if $uid;
409             }
410         }
411     }
412     
413     if (Bugzilla->params->{"supportwatchers"}) {
414         # Find all those user-watching anyone on the current list, who is not 
415         # on it already themselves.
416         my $involved = join(",", keys %recipients);
417
418         my $userwatchers = 
419             $dbh->selectall_arrayref("SELECT watcher, watched FROM watch 
420                                       WHERE watched IN ($involved)");
421
422         # Mark these people as having the role of the person they are watching
423         foreach my $watch (@$userwatchers) {
424             while (my ($role, $bits) = each %{$recipients{$watch->[1]}}) {
425                 $recipients{$watch->[0]}->{$role} |= BIT_WATCHING
426                     if $bits & BIT_DIRECT;
427             }
428             push (@{$watching{$watch->[0]}}, $watch->[1]);
429         }
430     }
431
432     # Global watcher
433     my @watchers = split(/[,\s]+/, Bugzilla->params->{'globalwatchers'});
434     foreach (@watchers) {
435         my $watcher_id = login_to_id($_);
436         next unless $watcher_id;
437         $recipients{$watcher_id}->{+REL_GLOBAL_WATCHER} = BIT_DIRECT;
438     }
439
440     # We now have a complete set of all the users, and their relationships to
441     # the bug in question. However, we are not necessarily going to mail them
442     # all - there are preferences, permissions checks and all sorts to do yet.
443     my @sent;
444     my @excluded;
445
446     # Some comments are language specific. We cache them here.
447     my %comments;
448
449     foreach my $user_id (keys %recipients) {
450         my %rels_which_want;
451         my $sent_mail = 0;
452
453         my $user = new Bugzilla::User($user_id);
454         # Deleted users must be excluded.
455         next unless $user;
456
457         # What's the language chosen by this user for email?
458         my $lang = $user->settings->{'lang'}->{'value'};
459
460         if ($user->can_see_bug($id)) {
461             # It's time to format language specific comments.
462             unless (exists $comments{$lang}) {
463                 Bugzilla->template_inner($lang);
464                 $comments{$lang} = prepare_comments($raw_comments, $count);
465                 Bugzilla->template_inner("");
466             }
467
468             # Go through each role the user has and see if they want mail in
469             # that role.
470             foreach my $relationship (keys %{$recipients{$user_id}}) {
471                 if ($user->wants_bug_mail($id,
472                                           $relationship, 
473                                           $diffs, 
474                                           $comments{$lang},
475                                           $deptext,
476                                           $changer,
477                                           !$start))
478                 {
479                     $rels_which_want{$relationship} = 
480                         $recipients{$user_id}->{$relationship};
481                 }
482             }
483         }
484         
485         if (scalar(%rels_which_want)) {
486             # So the user exists, can see the bug, and wants mail in at least
487             # one role. But do we want to send it to them?
488
489             # If we are using insiders, and the comment is private, only send 
490             # to insiders
491             my $insider_ok = 1;
492             $insider_ok = 0 if (Bugzilla->params->{"insidergroup"} && 
493                                 ($anyprivate != 0) && 
494                                 (!$user->groups->{Bugzilla->params->{"insidergroup"}}));
495
496             # We shouldn't send mail if this is a dependency mail (i.e. there 
497             # is something in @depbugs), and any of the depending bugs are not 
498             # visible to the user. This is to avoid leaking the summaries of 
499             # confidential bugs.
500             my $dep_ok = 1;
501             foreach my $dep_id (@depbugs) {
502                 if (!$user->can_see_bug($dep_id)) {
503                    $dep_ok = 0;
504                    last;
505                 }
506             }
507
508             # Make sure the user isn't in the nomail list, and the insider and 
509             # dep checks passed.
510             if ($user->email_enabled &&
511                 $insider_ok &&
512                 $dep_ok)
513             {
514                 # OK, OK, if we must. Email the user.
515                 $sent_mail = sendMail($user, 
516                                       \@headerlist,
517                                       \%rels_which_want, 
518                                       \%values,
519                                       \%defmailhead, 
520                                       \%fielddescription, 
521                                       \@diffparts,
522                                       $comments{$lang},
523                                       $anyprivate, 
524                                       ! $start, 
525                                       $id,
526                                       exists $watching{$user_id} ?
527                                              $watching{$user_id} : undef);
528             }
529         }
530        
531         if ($sent_mail) {
532             push(@sent, $user->login); 
533         } 
534         else {
535             push(@excluded, $user->login); 
536         } 
537     }
538     
539     $dbh->do('UPDATE bugs SET lastdiffed = ? WHERE bug_id = ?',
540              undef, ($end, $id));
541
542     return {'sent' => \@sent, 'excluded' => \@excluded};
543 }
544
545 sub sendMail {
546     my ($user, $hlRef, $relRef, $valueRef, $dmhRef, $fdRef,
547         $diffRef, $newcomments, $anyprivate, $isnew,
548         $id, $watchingRef) = @_;
549
550     my %values = %$valueRef;
551     my @headerlist = @$hlRef;
552     my %mailhead = %$dmhRef;
553     my %fielddescription = %$fdRef;
554     my @diffparts = @$diffRef;    
555     
556     # Build difftext (the actions) by verifying the user should see them
557     my $difftext = "";
558     my $diffheader = "";
559     my $add_diff;
560
561     foreach my $diff (@diffparts) {
562         $add_diff = 0;
563         
564         if (exists($diff->{'fieldname'}) && 
565             ($diff->{'fieldname'} eq 'estimated_time' ||
566              $diff->{'fieldname'} eq 'remaining_time' ||
567              $diff->{'fieldname'} eq 'work_time' ||
568              $diff->{'fieldname'} eq 'deadline')){
569             if ($user->groups->{Bugzilla->params->{"timetrackinggroup"}}) {
570                 $add_diff = 1;
571             }
572         } elsif (($diff->{'isprivate'}) 
573                  && Bugzilla->params->{'insidergroup'}
574                  && !($user->groups->{Bugzilla->params->{'insidergroup'}})
575                 ) {
576             $add_diff = 0;
577         } else {
578             $add_diff = 1;
579         }
580
581         if ($add_diff) {
582             if (exists($diff->{'header'}) && 
583              ($diffheader ne $diff->{'header'})) {
584                 $diffheader = $diff->{'header'};
585                 $difftext .= $diffheader;
586             }
587             $difftext .= $diff->{'text'};
588         }
589     }
590  
591     if ($difftext eq "" && $newcomments eq "" && !$isnew) {
592       # Whoops, no differences!
593       return 0;
594     }
595     
596     # If an attachment was created, then add an URL. (Note: the 'g'lobal
597     # replace should work with comments with multiple attachments.)
598
599     if ( $newcomments =~ /Created an attachment \(/ ) {
600
601         my $showattachurlbase =
602             Bugzilla->params->{'urlbase'} . "attachment.cgi?id=";
603
604         $newcomments =~ s/(Created an attachment \(id=([0-9]+)\))/$1\n --> \(${showattachurlbase}$2\)/g;
605     }
606
607     my $diffs = $difftext . "\n\n" . $newcomments;
608     if ($isnew) {
609         my $head = "";
610         foreach my $f (@headerlist) {
611             next unless $mailhead{$f};
612             my $value = $values{$f};
613             # If there isn't anything to show, don't include this header.
614             next unless $value;
615             # Only send estimated_time if it is enabled and the user is in the group.
616             if (($f ne 'estimated_time' && $f ne 'deadline')
617                 || $user->groups->{Bugzilla->params->{'timetrackinggroup'}})
618             {
619                 my $desc = $fielddescription{$f};
620                 $head .= multiline_sprintf(FORMAT_DOUBLE, ["$desc:", $value],
621                                            FORMAT_2_SIZE);
622             }
623         }
624         $diffs = $head . ($difftext ? "\n\n" : "") . $diffs;
625     }
626
627     my (@reasons, @reasons_watch);
628     while (my ($relationship, $bits) = each %{$relRef}) {
629         push(@reasons, $relationship) if ($bits & BIT_DIRECT);
630         push(@reasons_watch, $relationship) if ($bits & BIT_WATCHING);
631     }
632
633     my @headerrel   = map { REL_NAMES->{$_} } @reasons;
634     my @watchingrel = map { REL_NAMES->{$_} } @reasons_watch;
635     push(@headerrel,   'None') unless @headerrel;
636     push(@watchingrel, 'None') unless @watchingrel;
637     push @watchingrel, map { user_id_to_login($_) } @$watchingRef;
638
639     my $threadingmarker = build_thread_marker($id, $user->id, $isnew);
640
641     my $vars = {
642         isnew => $isnew,
643         to => $user->email,
644         bugid => $id,
645         alias => Bugzilla->params->{'usebugaliases'} ? $values{'alias'} : "",
646         classification => $values{'classification'},
647         product => $values{'product'},
648         comp => $values{'component'},
649         keywords => $values{'keywords'},
650         severity => $values{'bug_severity'},
651         status => $values{'bug_status'},
652         priority => $values{'priority'},
653         assignedto => $values{'assigned_to'},
654         assignedtoname => Bugzilla::User->new({name => $values{'assigned_to'}})->name,
655         targetmilestone => $values{'target_milestone'},
656         changedfields => $values{'changed_fields'},
657         summary => $values{'short_desc'},
658         reasons => \@reasons,
659         reasons_watch => \@reasons_watch,
660         reasonsheader => join(" ", @headerrel),
661         reasonswatchheader => join(" ", @watchingrel),
662         changer => $values{'changer'},
663         changername => $values{'changername'},
664         reporter => $values{'reporter'},
665         reportername => Bugzilla::User->new({name => $values{'reporter'}})->name,
666         diffs => $diffs,
667         threadingmarker => $threadingmarker
668     };
669
670     my $msg;
671     my $template = Bugzilla->template_inner($user->settings->{'lang'}->{'value'});
672     $template->process("email/newchangedmail.txt.tmpl", $vars, \$msg)
673       || ThrowTemplateError($template->error());
674     Bugzilla->template_inner("");
675
676     MessageToMTA($msg);
677
678     return 1;
679 }
680
681 # Get bug comments for the given period.
682 sub get_comments_by_bug {
683     my ($id, $start, $end) = @_;
684     my $dbh = Bugzilla->dbh;
685
686     my $result = "";
687     my $count = 0;
688     my $anyprivate = 0;
689
690     # $start will be undef for new bugs, and defined for pre-existing bugs.
691     if ($start) {
692         # If $start is not NULL, obtain the count-index
693         # of this comment for the leading "Comment #xxx" line.
694         $count = $dbh->selectrow_array('SELECT COUNT(*) FROM longdescs
695                                         WHERE bug_id = ? AND bug_when <= ?',
696                                         undef, ($id, $start));
697     }
698
699     my $raw = 1; # Do not format comments which are not of type CMT_NORMAL.
700     my $comments = Bugzilla::Bug::GetComments($id, "oldest_to_newest", $start, $end, $raw);
701
702     if (Bugzilla->params->{'insidergroup'}) {
703         $anyprivate = 1 if scalar(grep {$_->{'isprivate'} > 0} @$comments);
704     }
705
706     return ($comments, $anyprivate, $count);
707 }
708
709 # Prepare comments for the given language.
710 sub prepare_comments {
711     my ($raw_comments, $count) = @_;
712
713     my $result = "";
714     foreach my $comment (@$raw_comments) {
715         if ($count) {
716             $result .= "\n\n--- Comment #$count from " . $comment->{'author'}->identity .
717                        "  " . format_time($comment->{'time'}) . " ---\n";
718         }
719         # Format language specific comments. We don't update $comment->{'body'}
720         # directly, otherwise it would grow everytime you call format_comment()
721         # with a different language as some text may be appended to the existing one.
722         my $body = Bugzilla::Bug::format_comment($comment);
723         $result .= ($comment->{'already_wrapped'} ? $body : wrap_comment($body));
724         $count++;
725     }
726     return $result;
727 }
728
729 1;