blob: 110a1ffaf9fd5e672a9a57e17ae5f14252ad1673 [file] [log] [blame]
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This Source Code Form is "Incompatible With Secondary Licenses", as
# defined by the Mozilla Public License, v. 2.0.
package Bugzilla::BugMail;
use 5.10.1;
use strict;
use warnings;
use Bugzilla::Error;
use Bugzilla::User;
use Bugzilla::Constants;
use Bugzilla::Util;
use Bugzilla::Bug;
use Bugzilla::Comment;
use Bugzilla::Mailer;
use Bugzilla::Hook;
use Bugzilla::MIME;
use Date::Parse;
use Date::Format;
use Scalar::Util qw(blessed);
use List::MoreUtils qw(uniq);
use Storable qw(dclone);
use constant BIT_DIRECT => 1;
use constant BIT_WATCHING => 2;
sub relationships {
my $ref = RELATIONSHIPS;
# Clone it so that we don't modify the constant;
my %relationships = %$ref;
Bugzilla::Hook::process('bugmail_relationships',
{ relationships => \%relationships });
return %relationships;
}
# args: bug_id, and an optional hash ref which may have keys for:
# changer, owner, qa, reporter, cc
# Optional hash contains values of people which will be forced to those
# roles when the email is sent.
# All the names are email addresses, not userids
# values are scalars, except for cc, which is a list
sub Send {
my ($id, $forced, $params) = @_;
$params ||= {};
my $dbh = Bugzilla->dbh;
my $bug = new Bugzilla::Bug($id);
my $start = $bug->lastdiffed;
my $end = $dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)');
# Bugzilla::User objects of people in various roles. More than one person
# can 'have' a role, if the person in that role has changed, or people are
# watching.
my @assignees = ($bug->assigned_to);
my @qa_contacts = $bug->qa_contact || ();
my @ccs = @{ $bug->cc_users };
# Include the people passed in as being in particular roles.
# This can include people who used to hold those roles.
# At this point, we don't care if there are duplicates in these arrays.
my $changer = $forced->{'changer'};
if ($forced->{'owner'}) {
push (@assignees, Bugzilla::User->check($forced->{'owner'}));
}
if ($forced->{'qacontact'}) {
push (@qa_contacts, Bugzilla::User->check($forced->{'qacontact'}));
}
if ($forced->{'cc'}) {
foreach my $cc (@{$forced->{'cc'}}) {
push(@ccs, Bugzilla::User->check($cc));
}
}
my %user_cache = map { $_->id => $_ } (@assignees, @qa_contacts, @ccs);
my @diffs;
if (!$start) {
@diffs = _get_new_bugmail_fields($bug);
}
my $comments = [];
if ($params->{dep_only}) {
push(@diffs, { field_name => 'bug_status',
old => $params->{changes}->{bug_status}->[0],
new => $params->{changes}->{bug_status}->[1],
login_name => $changer->login,
who => $changer,
blocker => $params->{blocker} },
{ field_name => 'resolution',
old => $params->{changes}->{resolution}->[0],
new => $params->{changes}->{resolution}->[1],
login_name => $changer->login,
who => $changer,
blocker => $params->{blocker} });
}
else {
push(@diffs, _get_diffs($bug, $end, \%user_cache));
$comments = $bug->comments({ after => $start, to => $end });
# Skip empty comments.
@$comments = grep { $_->type || $_->body =~ /\S/ } @$comments;
# If no changes have been made, there is no need to process further.
return {'sent' => []} unless scalar(@diffs) || scalar(@$comments);
}
###########################################################################
# Start of email filtering code
###########################################################################
# A user_id => roles hash to keep track of people.
my %recipients;
my %watching;
# We also record bugs that are referenced
my @referenced_bug_ids = ();
# Now we work out all the people involved with this bug, and note all of
# the relationships in a hash. The keys are userids, the values are an
# array of role constants.
# CCs
$recipients{$_->id}->{+REL_CC} = BIT_DIRECT foreach (@ccs);
# Reporter (there's only ever one)
$recipients{$bug->reporter->id}->{+REL_REPORTER} = BIT_DIRECT;
# QA Contact
if (Bugzilla->params->{'useqacontact'}) {
foreach (@qa_contacts) {
# QA Contact can be blank; ignore it if so.
$recipients{$_->id}->{+REL_QA} = BIT_DIRECT if $_;
}
}
# Assignee
$recipients{$_->id}->{+REL_ASSIGNEE} = BIT_DIRECT foreach (@assignees);
# The last relevant set of people are those who are being removed from
# their roles in this change. We get their names out of the diffs.
foreach my $change (@diffs) {
if ($change->{old}) {
# You can't stop being the reporter, so we don't check that
# relationship here.
# Ignore people whose user account has been deleted or renamed.
if ($change->{field_name} eq 'cc') {
foreach my $cc_user (split(/[\s,]+/, $change->{old})) {
my $uid = login_to_id($cc_user);
$recipients{$uid}->{+REL_CC} = BIT_DIRECT if $uid;
}
}
elsif ($change->{field_name} eq 'qa_contact') {
my $uid = login_to_id($change->{old});
$recipients{$uid}->{+REL_QA} = BIT_DIRECT if $uid;
}
elsif ($change->{field_name} eq 'assigned_to') {
my $uid = login_to_id($change->{old});
$recipients{$uid}->{+REL_ASSIGNEE} = BIT_DIRECT if $uid;
}
}
if ($change->{field_name} eq 'dependson' || $change->{field_name} eq 'blocked') {
push @referenced_bug_ids, split(/[\s,]+/, $change->{old} // '');
push @referenced_bug_ids, split(/[\s,]+/, $change->{new} // '');
}
}
my $referenced_bugs = scalar(@referenced_bug_ids)
? Bugzilla::Bug->new_from_list([uniq @referenced_bug_ids])
: [];
# Make sure %user_cache has every user in it so far referenced
foreach my $user_id (keys %recipients) {
$user_cache{$user_id} ||= new Bugzilla::User($user_id);
}
Bugzilla::Hook::process('bugmail_recipients',
{ bug => $bug, recipients => \%recipients,
users => \%user_cache, diffs => \@diffs });
# We should not assume %recipients to have any entries.
if (scalar keys %recipients) {
# Find all those user-watching anyone on the current list, who is not
# on it already themselves.
my $involved = join(",", keys %recipients);
my $userwatchers =
$dbh->selectall_arrayref("SELECT watcher, watched FROM watch
WHERE watched IN ($involved)");
# Mark these people as having the role of the person they are watching
foreach my $watch (@$userwatchers) {
while (my ($role, $bits) = each %{$recipients{$watch->[1]}}) {
$recipients{$watch->[0]}->{$role} |= BIT_WATCHING
if $bits & BIT_DIRECT;
}
push(@{$watching{$watch->[0]}}, $watch->[1]);
}
}
# Global watcher
my @watchers = split(/[,\s]+/, Bugzilla->params->{'globalwatchers'});
foreach (@watchers) {
my $watcher_id = login_to_id($_);
next unless $watcher_id;
$recipients{$watcher_id}->{+REL_GLOBAL_WATCHER} = BIT_DIRECT;
}
# We now have a complete set of all the users, and their relationships to
# the bug in question. However, we are not necessarily going to mail them
# all - there are preferences, permissions checks and all sorts to do yet.
my @sent;
# The email client will display the Date: header in the desired timezone,
# so we can always use UTC here.
my $date = $params->{dep_only} ? $end : $bug->delta_ts;
$date = format_time($date, '%a, %d %b %Y %T %z', 'UTC');
foreach my $user_id (keys %recipients) {
my %rels_which_want;
my $user = $user_cache{$user_id} ||= new Bugzilla::User($user_id);
# Deleted users must be excluded.
next unless $user;
# If email notifications are disabled for this account, or the bug
# is ignored, there is no need to do additional checks.
next if ($user->email_disabled || $user->is_bug_ignored($id));
if ($user->can_see_bug($id)) {
# Go through each role the user has and see if they want mail in
# that role.
foreach my $relationship (keys %{$recipients{$user_id}}) {
if ($user->wants_bug_mail($bug,
$relationship,
$start ? \@diffs : [],
$comments,
$params->{dep_only},
$changer))
{
$rels_which_want{$relationship} =
$recipients{$user_id}->{$relationship};
}
}
}
if (scalar(%rels_which_want)) {
# So the user exists, can see the bug, and wants mail in at least
# one role. But do we want to send it to them?
# We shouldn't send mail if this is a dependency mail and the
# depending bug is not visible to the user.
# This is to avoid leaking the summary of a confidential bug.
my $dep_ok = 1;
if ($params->{dep_only}) {
$dep_ok = $user->can_see_bug($params->{blocker}->id) ? 1 : 0;
}
# Email the user if the dep check passed.
if ($dep_ok) {
my $sent_mail = sendMail(
{ to => $user,
bug => $bug,
comments => $comments,
date => $date,
changer => $changer,
watchers => exists $watching{$user_id} ?
$watching{$user_id} : undef,
diffs => \@diffs,
rels_which_want => \%rels_which_want,
dep_only => $params->{dep_only},
referenced_bugs => $referenced_bugs,
});
push(@sent, $user->login) if $sent_mail;
}
}
}
# When sending bugmail about a blocker being reopened or resolved,
# we say nothing about changes in the bug being blocked, so we must
# not update lastdiffed in this case.
if (!$params->{dep_only}) {
$dbh->do('UPDATE bugs SET lastdiffed = ? WHERE bug_id = ?',
undef, ($end, $id));
$bug->{lastdiffed} = $end;
}
return {'sent' => \@sent};
}
sub sendMail {
my $params = shift;
my $user = $params->{to};
my $bug = $params->{bug};
my @send_comments = @{ $params->{comments} };
my $date = $params->{date};
my $changer = $params->{changer};
my $watchingRef = $params->{watchers};
my @diffs = @{ $params->{diffs} };
my $relRef = $params->{rels_which_want};
my $dep_only = $params->{dep_only};
my $referenced_bugs = $params->{referenced_bugs};
# Only display changes the user is allowed see.
my @display_diffs;
foreach my $diff (@diffs) {
my $add_diff = 0;
if (grep { $_ eq $diff->{field_name} } TIMETRACKING_FIELDS) {
$add_diff = 1 if $user->is_timetracker;
}
elsif (!$diff->{isprivate} || $user->is_insider) {
$add_diff = 1;
}
push(@display_diffs, $diff) if $add_diff;
}
if (!$user->is_insider) {
@send_comments = grep { !$_->is_private } @send_comments;
}
if (!scalar(@display_diffs) && !scalar(@send_comments)) {
# Whoops, no differences!
return 0;
}
my (@reasons, @reasons_watch);
while (my ($relationship, $bits) = each %{$relRef}) {
push(@reasons, $relationship) if ($bits & BIT_DIRECT);
push(@reasons_watch, $relationship) if ($bits & BIT_WATCHING);
}
my %relationships = relationships();
my @headerrel = map { $relationships{$_} } @reasons;
my @watchingrel = map { $relationships{$_} } @reasons_watch;
push(@headerrel, 'None') unless @headerrel;
push(@watchingrel, 'None') unless @watchingrel;
push @watchingrel, map { Bugzilla::User->new($_)->login } @$watchingRef;
my @changedfields = uniq map { $_->{field_name} } @display_diffs;
# Add attachments.created to changedfields if one or more
# comments contain information about a new attachment
if (grep($_->type == CMT_ATTACHMENT_CREATED, @send_comments)) {
push(@changedfields, 'attachments.created');
}
my $bugmailtype = "changed";
$bugmailtype = "new" if !$bug->lastdiffed;
$bugmailtype = "dep_changed" if $dep_only;
my $vars = {
date => $date,
to_user => $user,
bug => $bug,
reasons => \@reasons,
reasons_watch => \@reasons_watch,
reasonsheader => join(" ", @headerrel),
reasonswatchheader => join(" ", @watchingrel),
changer => $changer,
diffs => \@display_diffs,
changedfields => \@changedfields,
referenced_bugs => $user->visible_bugs($referenced_bugs),
new_comments => \@send_comments,
threadingmarker => build_thread_marker($bug->id, $user->id, !$bug->lastdiffed),
bugmailtype => $bugmailtype,
};
if (Bugzilla->params->{'use_mailer_queue'}) {
enqueue($vars);
} else {
MessageToMTA(_generate_bugmail($vars));
}
return 1;
}
sub enqueue {
my ($vars) = @_;
# we need to flatten all objects to a hash before pushing to the job queue.
# the hashes need to be inflated in the dequeue method.
$vars->{bug} = _flatten_object($vars->{bug});
$vars->{to_user} = _flatten_object($vars->{to_user});
$vars->{changer} = _flatten_object($vars->{changer});
$vars->{new_comments} = [ map { _flatten_object($_) } @{ $vars->{new_comments} } ];
foreach my $diff (@{ $vars->{diffs} }) {
$diff->{who} = _flatten_object($diff->{who});
if (exists $diff->{blocker}) {
$diff->{blocker} = _flatten_object($diff->{blocker});
}
}
Bugzilla->job_queue->insert('bug_mail', { vars => $vars });
}
sub dequeue {
my ($payload) = @_;
# clone the payload so we can modify it without impacting TheSchwartz's
# ability to process the job when we've finished
my $vars = dclone($payload);
# inflate objects
$vars->{bug} = Bugzilla::Bug->new_from_hash($vars->{bug});
$vars->{to_user} = Bugzilla::User->new_from_hash($vars->{to_user});
$vars->{changer} = Bugzilla::User->new_from_hash($vars->{changer});
$vars->{new_comments} = [ map { Bugzilla::Comment->new_from_hash($_) } @{ $vars->{new_comments} } ];
foreach my $diff (@{ $vars->{diffs} }) {
$diff->{who} = Bugzilla::User->new_from_hash($diff->{who});
if (exists $diff->{blocker}) {
$diff->{blocker} = Bugzilla::Bug->new_from_hash($diff->{blocker});
}
}
# generate bugmail and send
MessageToMTA(_generate_bugmail($vars), 1);
}
sub _flatten_object {
my ($object) = @_;
# nothing to do if it's already flattened
return $object unless blessed($object);
# the same objects are used for each recipient, so cache the flattened hash
my $cache = Bugzilla->request_cache->{bugmail_flat_objects} ||= {};
my $key = blessed($object) . '-' . $object->id;
return $cache->{$key} ||= $object->flatten_to_hash;
}
sub _generate_bugmail {
my ($vars) = @_;
my $user = $vars->{to_user};
my $template = Bugzilla->template_inner($user->setting('lang'));
my ($msg_text, $msg_html, $msg_header);
state $use_utf8 = Bugzilla->params->{'utf8'};
$template->process("email/bugmail-header.txt.tmpl", $vars, \$msg_header)
|| ThrowTemplateError($template->error());
$template->process("email/bugmail.txt.tmpl", $vars, \$msg_text)
|| ThrowTemplateError($template->error());
my @parts = (
Bugzilla::MIME->create(
attributes => {
content_type => 'text/plain',
charset => $use_utf8 ? 'UTF-8' : 'iso-8859-1',
encoding => 'quoted-printable',
},
body_str => $msg_text,
)
);
if ($user->setting('email_format') eq 'html') {
$template->process("email/bugmail.html.tmpl", $vars, \$msg_html)
|| ThrowTemplateError($template->error());
push @parts, Bugzilla::MIME->create(
attributes => {
content_type => 'text/html',
charset => $use_utf8 ? 'UTF-8' : 'iso-8859-1',
encoding => 'quoted-printable',
},
body_str => $msg_html,
);
}
my $email = Bugzilla::MIME->new($msg_header);
if (scalar(@parts) == 1) {
$email->content_type_set($parts[0]->content_type);
} else {
$email->content_type_set('multipart/alternative');
# Some mail clients need same encoding for each part, even empty ones.
$email->charset_set('UTF-8') if $use_utf8;
}
$email->parts_set(\@parts);
return $email;
}
sub _get_diffs {
my ($bug, $end, $user_cache) = @_;
my $dbh = Bugzilla->dbh;
my @args = ($bug->id);
# If lastdiffed is NULL, then we don't limit the search on time.
my $when_restriction = '';
if ($bug->lastdiffed) {
$when_restriction = ' AND bug_when > ? AND bug_when <= ?';
push @args, ($bug->lastdiffed, $end);
}
my $diffs = $dbh->selectall_arrayref(
"SELECT fielddefs.name AS field_name,
bugs_activity.bug_when, bugs_activity.removed AS old,
bugs_activity.added AS new, bugs_activity.attach_id,
bugs_activity.comment_id, bugs_activity.who
FROM bugs_activity
INNER JOIN fielddefs
ON fielddefs.id = bugs_activity.fieldid
WHERE bugs_activity.bug_id = ?
$when_restriction
ORDER BY bugs_activity.bug_when, bugs_activity.id",
{Slice=>{}}, @args);
foreach my $diff (@$diffs) {
$user_cache->{$diff->{who}} ||= new Bugzilla::User($diff->{who});
$diff->{who} = $user_cache->{$diff->{who}};
if ($diff->{attach_id}) {
$diff->{isprivate} = $dbh->selectrow_array(
'SELECT isprivate FROM attachments WHERE attach_id = ?',
undef, $diff->{attach_id});
}
if ($diff->{field_name} eq 'longdescs.isprivate') {
my $comment = Bugzilla::Comment->new($diff->{comment_id});
$diff->{num} = $comment->count;
$diff->{isprivate} = $diff->{new};
}
}
my @changes = ();
foreach my $diff (@$diffs) {
# If this is the same field as the previous item, then concatenate
# the data into the same change.
if (scalar(@changes)
&& $diff->{field_name} eq $changes[-1]->{field_name}
&& $diff->{bug_when} eq $changes[-1]->{bug_when}
&& $diff->{who} eq $changes[-1]->{who}
&& ($diff->{attach_id} // 0) == ($changes[-1]->{attach_id} // 0)
&& ($diff->{comment_id} // 0) == ($changes[-1]->{comment_id} // 0)
) {
my $old_change = pop @changes;
$diff->{old} = join_activity_entries($diff->{field_name}, $old_change->{old}, $diff->{old});
$diff->{new} = join_activity_entries($diff->{field_name}, $old_change->{new}, $diff->{new});
}
push @changes, $diff;
}
return @changes;
}
sub _get_new_bugmail_fields {
my $bug = shift;
my @fields = @{ Bugzilla->fields({obsolete => 0, in_new_bugmail => 1}) };
my @diffs;
my $params = Bugzilla->params;
foreach my $field (@fields) {
my $name = $field->name;
my $value = $bug->$name;
next if !$field->is_visible_on_bug($bug)
|| ($name eq 'classification' && !$params->{'useclassification'})
|| ($name eq 'status_whiteboard' && !$params->{'usestatuswhiteboard'})
|| ($name eq 'qa_contact' && !$params->{'useqacontact'})
|| ($name eq 'target_milestone' && !$params->{'usetargetmilestone'});
if (ref $value eq 'ARRAY') {
$value = join(', ', @$value);
}
elsif (blessed($value) && $value->isa('Bugzilla::User')) {
$value = $value->login;
}
elsif (blessed($value) && $value->isa('Bugzilla::Object')) {
$value = $value->name;
}
elsif ($name eq 'estimated_time') {
# "0.00" (which is what we get from the DB) is true,
# so we explicitly do a numerical comparison with 0.
$value = 0 if $value == 0;
}
elsif ($name eq 'deadline') {
$value = time2str("%Y-%m-%d", str2time($value)) if $value;
}
# If there isn't anything to show, don't include this header.
next unless $value;
push(@diffs, {
field_name => $name,
who => $bug->reporter,
new => $value});
}
return @diffs;
}
1;
=head1 NAME
BugMail - Routines to generate email notifications when a bug is created or
modified.
=head1 METHODS
=over 4
=item C<enqueue>
Serialises the variables required to generate bugmail and pushes the result to
the job-queue for processing by TheSchwartz.
=item C<dequeue>
When given serialised variables from the job-queue, recreates the objects from
the flattened hashes, generates the bugmail, and sends it.
=back
=head1 B<Methods in need of POD>
=over
=item relationships
=item sendMail
=item Send
=back