path: root/extensions/BugmailFilter/Extension.pm

# 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::Extension::BugmailFilter;

use 5.10.1;
use strict;
use warnings;

use base qw(Bugzilla::Extension);
our $VERSION = '1';

use Bugzilla::BugMail;
use Bugzilla::Component;
use Bugzilla::Constants;
use Bugzilla::Error;
use Bugzilla::Extension::BugmailFilter::Constants;
use Bugzilla::Extension::BugmailFilter::FakeField;
use Bugzilla::Extension::BugmailFilter::Filter;
use Bugzilla::Field;
use Bugzilla::Product;
use Bugzilla::User;
use Bugzilla::Util qw(template_var);
use Encode;
use List::MoreUtils qw(uniq);
use Sys::Syslog qw(:DEFAULT);

#
# preferences
#

sub user_preferences {
    my ($self, $args) = @_;
    return unless $args->{current_tab} eq 'bugmail_filter';

    if ($args->{save_changes}) {
        my $input = Bugzilla->input_params;

        if ($input->{add_filter}) {

            # add a new filter

            my $params = {
                user_id => Bugzilla->user->id,
            };
            $params->{field_name} = $input->{field} || IS_NULL;
            if ($params->{field_name} eq '~') {
                $params->{field_name} = '~' . $input->{field_contains};
            }
            $params->{relationship} = $input->{relationship} || IS_NULL;
            if ($input->{changer}) {
                Bugzilla::User::match_field({ changer => { type => 'single'} });
                $params->{changer_id} = Bugzilla::User->check({
                    name  => $input->{changer},
                    cache => 1,
                })->id;
            }
            else {
                $params->{changer_id} = IS_NULL;
            }
            if (my $product_name = $input->{product}) {
                my $product = Bugzilla::Product->check({
                    name => $product_name, cache => 1
                });
                $params->{product_id} = $product->id;

                if (my $component_name = $input->{component}) {
                    $params->{component_id} = Bugzilla::Component->check({
                        name  => $component_name, product => $product,
                        cache => 1
                    })->id;
                }
                else {
                    $params->{component_id} = IS_NULL;
                }
            }
            else {
                $params->{product_id} = IS_NULL;
                $params->{component_id} = IS_NULL;
            }

            if (@{ Bugzilla::Extension::BugmailFilter::Filter->match($params) }) {
                ThrowUserError('bugmail_filter_exists');
            }
            $params->{action} = $input->{action} eq 'Exclude' ? 1 : 0;
            foreach my $name (keys %$params) {
                $params->{$name} = undef
                    if $params->{$name} eq IS_NULL;
            }
            Bugzilla::Extension::BugmailFilter::Filter->create($params);
        }

        elsif ($input->{remove_filter}) {

            # remove filter(s)

            my $ids = ref($input->{remove}) ? $input->{remove} : [ $input->{remove} ];
            my $dbh = Bugzilla->dbh;
            my $user = Bugzilla->user;

            my $filters = Bugzilla::Extension::BugmailFilter::Filter->match({ id => $ids, user_id => $user->id });
            $dbh->bz_start_transaction;
            foreach my $filter (@$filters) {
                $filter->remove_from_db();
            }
            $dbh->bz_commit_transaction;
        }
    }

    my $vars = $args->{vars};
    my $field_descs = template_var('field_descs');

    # load all fields into a hash for easy manipulation
    my %fields =
        map { $_->name => $field_descs->{$_->name} }
        @{ Bugzilla->fields({ obsolete => 0 }) };

    # remove time trackinger fields
    if (!Bugzilla->user->is_timetracker) {
        foreach my $field (TIMETRACKING_FIELDS) {
            delete $fields{$field};
        }
    }

    # remove fields which don't make any sense to filter on
    foreach my $field (IGNORE_FIELDS) {
        delete $fields{$field};
    }

    # remove all tracking flag fields.  these change too frequently to be of
    # value, so they only add noise to the list.
    foreach my $field (Bugzilla->tracking_flag_names) {
        delete $fields{$field};
    }

    # add tracking flag types instead
    foreach my $field (
        @{ Bugzilla::Extension::BugmailFilter::FakeField->tracking_flag_fields() }
    ) {
        $fields{$field->name} = $field->description;
    }

    # adjust the description for selected fields
    foreach my $field (keys %{ FIELD_DESCRIPTION_OVERRIDE() }) {
        $fields{$field} = FIELD_DESCRIPTION_OVERRIDE->{$field};
    }

    # some fields are present in the changed-fields x-header but are not real
    # bugzilla fields
    foreach my $field (
        @{ Bugzilla::Extension::BugmailFilter::FakeField->fake_fields() }
    ) {
        $fields{$field->name} = $field->description;
    }

    $vars->{fields} = \%fields;
    $vars->{field_list} = [
        sort { lc($a->{description}) cmp lc($b->{description}) }
        map { { name => $_, description => $fields{$_} } }
        keys %fields
    ];

    $vars->{relationships} = FILTER_RELATIONSHIPS();

    $vars->{filters} = [
        sort {
            $a->product_name cmp $b->product_name
            || $a->component_name cmp $b->component_name
            || $a->field_name cmp $b->field_name
        }
        @{ Bugzilla::Extension::BugmailFilter::Filter->match({
            user_id => Bugzilla->user->id,
        }) }
    ];

    # set field_description
    foreach my $filter (@{ $vars->{filters} }) {
        my $field_name = $filter->field_name;
        if (!$field_name) {
            $filter->field_description('Any');
        }
        elsif (substr($field_name, 0, 1) eq '~') {
            $filter->field_description('~ ' . substr($field_name, 1));
        }
        else {
            $filter->field_description($fields{$field_name} || $filter->field->description);
        }
    }

    # build a list of tracking-flags, grouped by type
    require Bugzilla::Extension::TrackingFlags::Constants;
    require Bugzilla::Extension::TrackingFlags::Flag;
    my %flag_types =
        map { $_->{name} => $_->{description} }
        @{ Bugzilla::Extension::TrackingFlags::Constants::FLAG_TYPES() };
    my %tracking_flags_by_type;
    foreach my $flag (Bugzilla::Extension::TrackingFlags::Flag->get_all) {
        my $type = $flag_types{$flag->flag_type};
        $tracking_flags_by_type{$type} //= [];
        push @{ $tracking_flags_by_type{$type} }, $flag;
    }
    my @tracking_flags_by_type;
    foreach my $type (sort keys %tracking_flags_by_type) {
        push @tracking_flags_by_type, {
            name  => $type,
            flags => $tracking_flags_by_type{$type},
        };
    }
    $vars->{tracking_flags_by_type} = \@tracking_flags_by_type;

    ${ $args->{handled} } = 1;
}

#
# hooks
#

sub user_wants_mail {
    my ($self, $args) = @_;
    my ($user, $wants_mail, $diffs, $comments)
        = @$args{qw( user wants_mail fieldDiffs comments )};

    # already filtered by email prefs
    return unless $$wants_mail;

    # avoid recursion
    my $depth = 0;
    for (my $stack = 1; my $sub = (caller($stack))[3]; $stack++) {
        $depth++ if $sub eq 'Bugzilla::User::wants_bug_mail';
    }
    return if $depth > 1;

    my $cache = Bugzilla->request_cache->{bugmail_filters} //= {};
    my $filters = $cache->{$user->id} //=
        Bugzilla::Extension::BugmailFilter::Filter->match({
        user_id => $user->id
    });
    return unless @$filters;

    my $fields = [
        map { {
            filter_field => $_->{field_name}, # filter's field_name
            field_name   => $_->{field_name}, # raw bugzilla field_name
        } }
        grep {
            # flags are added later
            $_->{field_name} ne 'flagtypes.name'
        }
        @$diffs
    ];

    # if more than one field was changed we need to check if the normal email
    # preferences would have excluded the field.
    if (@$fields > 1) {
        # check each field individually and create filter objects if required
        my @arg_list = @$args{qw( bug relationship fieldDiffs comments dep_mail changer )};
        foreach my $field (@$fields) {
            # just a single diff
            foreach my $diff (@$diffs) {
                next unless $diff->{field_name} eq $field->{field_name};
                $arg_list[2] = [ $diff ];
                last;
            }
            if (!$user->wants_bug_mail(@arg_list)) {
                # changes to just this field would have been dropped by email
                # preferences.  build a corresponding filter object so we
                # interact with email preferences correctly.
                push @$filters, Bugzilla::Extension::BugmailFilter::Filter->new_from_hash({
                    field_name => $field->{field_name},
                    action     => 1,
                });
            }
        }
    }

    # insert fake fields for new attachments and comments
    if (@$comments) {
        if (grep { $_->type == CMT_ATTACHMENT_CREATED } @$comments) {
            push @$fields, { field_name   => 'attachment.created',
                             filter_field => 'attachment.created' };
        }
        if (grep { $_->type != CMT_ATTACHMENT_CREATED } @$comments) {
            push @$fields, { field_name   => 'comment.created',
                             filter_field => 'comment.created' };
        }
    }

    # insert fake fields for flags
    foreach my $diff (@$diffs) {
        next unless $diff->{field_name} eq 'flagtypes.name';
        foreach my $change (split(/, /, join(', ', ($diff->{old}, $diff->{new})))) {
            next unless $change =~ /^(.+)[\?\-+]/;
            push @$fields, {
                filter_field => $1,
                field_name   => 'flagtypes.name',
            };
        }
    }

    # set filter_field on tracking flags to tracking.$type
    require Bugzilla::Extension::TrackingFlags::Flag;
    my @tracking_flags = Bugzilla->tracking_flags;
    foreach my $field (@$fields) {
        next unless my $field_name = $field->{field_name};
        foreach my $tracking_flag (@tracking_flags) {
            if ($field_name eq $tracking_flag->name) {
                $field->{filter_field} = 'tracking.'. $tracking_flag->flag_type;
            }
        }
    }

    if (_should_drop($fields, $filters, $args)) {
        $$wants_mail = 0;
        openlog('apache', 'cons,pid', 'local4');
        syslog('notice', encode_utf8(sprintf(
            '[bugmail] %s (filtered) bug-%s %s',
            $args->{user}->login,
            $args->{bug}->id,
            $args->{bug}->short_desc,
        )));
        closelog();
    }
}

sub _should_drop {
    my ($fields, $filters, $args) = @_;

    # calculate relationships

    my ($user, $bug, $relationship, $changer) = @$args{qw( user bug relationship changer )};
    my ($user_id, $login) = ($user->id, $user->login);
    my $bit_direct    = Bugzilla::BugMail::BIT_DIRECT;
    my $bit_watching  = Bugzilla::BugMail::BIT_WATCHING;
    my $bit_compwatch = 15; # from Bugzilla::Extension::ComponentWatching

    # the index of $rel_map corresponds to the values in FILTER_RELATIONSHIPS
    my @rel_map;
    $rel_map[1] = $bug->assigned_to->id == $user_id;
    $rel_map[2] = !$rel_map[1];
    $rel_map[3] = $bug->reporter->id == $user_id;
    $rel_map[4] = !$rel_map[3];
    if ($bug->qa_contact) {
        $rel_map[5] = $bug->qa_contact->id == $user_id;
        $rel_map[6] = !$rel_map[6];
    }
    $rel_map[7] = $bug->cc
                  ? grep { $_ eq $login } @{ $bug->cc }
                  : 0;
    $rel_map[8] = !$rel_map[8];
    $rel_map[9] = (
                    $relationship & $bit_watching
                    or $relationship & $bit_compwatch
                  );
    $rel_map[10] = !$rel_map[9];
    $rel_map[11] = $bug->is_mentor($user);
    $rel_map[12] = !$rel_map[11];
    foreach my $bool (@rel_map) {
        $bool = $bool ? 1 : 0;
    }

    # exclusions
    # drop email where we are excluding all changed fields

    my $params = {
        product_id   => $bug->product_id,
        component_id => $bug->component_id,
        rel_map      => \@rel_map,
        changer_id   => $changer->id,
    };

    foreach my $field (@$fields) {
        $params->{field} = $field;
        foreach my $filter (grep { $_->is_exclude } @$filters) {
            if ($filter->matches($params)) {
                $field->{exclude} = 1;
                last;
            }
        }
    }

    # no need to process includes if nothing was excluded
    if (!grep { $_->{exclude} } @$fields) {
        return 0;
    }

    # inclusions
    # flip the bit for fields that should be included

    foreach my $field (@$fields) {
        $params->{field} = $field;
        foreach my $filter (grep { $_->is_include } @$filters) {
            if ($filter->matches($params)) {
                $field->{exclude} = 0;
                last;
            }
        }
    }

    # drop if all fields are still excluded
    return !(grep { !$_->{exclude} } @$fields);
}

# catch when fields are renamed, and update the field_name entires
sub object_end_of_update {
    my ($self, $args) = @_;
    my $object = $args->{object};

    return unless $object->isa('Bugzilla::Field')
        || $object->isa('Bugzilla::Extension::TrackingFlags::Flag');

    return unless exists $args->{changes}->{name};

    my $old_name = $args->{changes}->{name}->[0];
    my $new_name = $args->{changes}->{name}->[1];

    Bugzilla->dbh->do(
        "UPDATE bugmail_filters SET field_name=? WHERE field_name=?",
        undef,
        $new_name, $old_name);
}

sub reorg_move_component {
    my ($self, $args) = @_;
    my $new_product = $args->{new_product};
    my $component   = $args->{component};

    Bugzilla->dbh->do(
        "UPDATE bugmail_filters SET product_id=? WHERE component_id=?",
        undef,
        $new_product->id, $component->id,
    );
}

#
# schema / install
#

sub db_schema_abstract_schema {
    my ($self, $args) = @_;
    $args->{schema}->{bugmail_filters} = {
        FIELDS => [
            id => {
                TYPE       => 'INTSERIAL',
                NOTNULL    => 1,
                PRIMARYKEY => 1,
            },
            user_id => {
                TYPE       => 'INT3',
                NOTNULL    => 1,
                REFERENCES => {
                    TABLE  => 'profiles',
                    COLUMN => 'userid',
                    DELETE => 'CASCADE'
                },
            },
            field_name => {
                # due to fake fields, this can't be field_id
                TYPE       => 'VARCHAR(64)',
                NOTNULL    => 0,
            },
            product_id => {
                TYPE       => 'INT2',
                NOTNULL    => 0,
                REFERENCES => {
                    TABLE  => 'products',
                    COLUMN => 'id',
                    DELETE => 'CASCADE'
                },
            },
            component_id => {
                TYPE       => 'INT2',
                NOTNULL    => 0,
                REFERENCES => {
                    TABLE  => 'components',
                    COLUMN => 'id',
                    DELETE => 'CASCADE'
                },
            },
            changer_id => {
                TYPE       => 'INT3',
                NOTNULL    => 0,
                REFERENCES => {
                    TABLE  => 'profiles',
                    COLUMN => 'userid',
                    DELETE => 'CASCADE'
                },
            },
            relationship => {
                TYPE       => 'INT2',
                NOTNULL    => 0,
            },
            action => {
                TYPE       => 'INT1',
                NOTNULL    => 1,
            },
        ],
        INDEXES => [
            bugmail_filters_unique_idx => {
                FIELDS  => [ qw( user_id field_name product_id component_id
                                 relationship ) ],
                TYPE    => 'UNIQUE',
            },
            bugmail_filters_user_idx => [
                'user_id',
            ],
        ],
    };
}

sub install_update_db {
    Bugzilla->dbh->bz_add_column(
        'bugmail_filters',
        'changer_id',
        {
            TYPE    => 'INT3',
            NOTNULL => 0,
        }
    );
}

sub db_sanitize {
    my $dbh = Bugzilla->dbh;
    print "Deleting bugmail filters...\n";
    $dbh->do("DELETE FROM bugmail_filters");
}

__PACKAGE__->NAME;