| # 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::Flag; |
| |
| use 5.10.1; |
| use strict; |
| use warnings; |
| |
| =head1 NAME |
| |
| Bugzilla::Flag - A module to deal with Bugzilla flag values. |
| |
| =head1 SYNOPSIS |
| |
| Flag.pm provides an interface to flags as stored in Bugzilla. |
| See below for more information. |
| |
| =head1 NOTES |
| |
| =over |
| |
| =item * |
| |
| Import relevant functions from that script. |
| |
| =item * |
| |
| Use of private functions / variables outside this module may lead to |
| unexpected results after an upgrade. Please avoid using private |
| functions in other files/modules. Private functions are functions |
| whose names start with _ or a re specifically noted as being private. |
| |
| =back |
| |
| =cut |
| |
| use Scalar::Util qw(blessed); |
| use Storable qw(dclone); |
| |
| use Bugzilla::FlagType; |
| use Bugzilla::Hook; |
| use Bugzilla::User; |
| use Bugzilla::Util; |
| use Bugzilla::Error; |
| use Bugzilla::Mailer; |
| use Bugzilla::Constants; |
| use Bugzilla::Field; |
| |
| use parent qw(Bugzilla::Object Exporter); |
| @Bugzilla::Flag::EXPORT = qw(SKIP_REQUESTEE_ON_ERROR); |
| |
| ############################### |
| #### Initialization #### |
| ############################### |
| |
| use constant DB_TABLE => 'flags'; |
| use constant LIST_ORDER => 'id'; |
| # Flags are tracked in bugs_activity. |
| use constant AUDIT_CREATES => 0; |
| use constant AUDIT_UPDATES => 0; |
| use constant AUDIT_REMOVES => 0; |
| |
| use constant SKIP_REQUESTEE_ON_ERROR => 1; |
| |
| sub DB_COLUMNS { |
| my $dbh = Bugzilla->dbh; |
| return qw( |
| id |
| type_id |
| bug_id |
| attach_id |
| requestee_id |
| setter_id |
| status), |
| $dbh->sql_date_format('creation_date', '%Y.%m.%d %H:%i:%s') . |
| ' AS creation_date', |
| $dbh->sql_date_format('modification_date', '%Y.%m.%d %H:%i:%s') . |
| ' AS modification_date'; |
| } |
| |
| use constant UPDATE_COLUMNS => qw( |
| requestee_id |
| setter_id |
| status |
| type_id |
| ); |
| |
| use constant VALIDATORS => { |
| }; |
| |
| use constant UPDATE_VALIDATORS => { |
| setter => \&_check_setter, |
| status => \&_check_status, |
| }; |
| |
| ############################### |
| #### Accessors ###### |
| ############################### |
| |
| =head2 METHODS |
| |
| =over |
| |
| =item C<id> |
| |
| Returns the ID of the flag. |
| |
| =item C<name> |
| |
| Returns the name of the flagtype the flag belongs to. |
| |
| =item C<bug_id> |
| |
| Returns the ID of the bug this flag belongs to. |
| |
| =item C<attach_id> |
| |
| Returns the ID of the attachment this flag belongs to, if any. |
| |
| =item C<status> |
| |
| Returns the status '+', '-', '?' of the flag. |
| |
| =item C<creation_date> |
| |
| Returns the timestamp when the flag was created. |
| |
| =item C<modification_date> |
| |
| Returns the timestamp when the flag was last modified. |
| |
| =back |
| |
| =cut |
| |
| sub id { return $_[0]->{'id'}; } |
| sub name { return $_[0]->type->name; } |
| sub type_id { return $_[0]->{'type_id'}; } |
| sub bug_id { return $_[0]->{'bug_id'}; } |
| sub attach_id { return $_[0]->{'attach_id'}; } |
| sub status { return $_[0]->{'status'}; } |
| sub setter_id { return $_[0]->{'setter_id'}; } |
| sub requestee_id { return $_[0]->{'requestee_id'}; } |
| sub creation_date { return $_[0]->{'creation_date'}; } |
| sub modification_date { return $_[0]->{'modification_date'}; } |
| |
| ############################### |
| #### Methods #### |
| ############################### |
| |
| =pod |
| |
| =over |
| |
| =item C<type> |
| |
| Returns the type of the flag, as a Bugzilla::FlagType object. |
| |
| =item C<setter> |
| |
| Returns the user who set the flag, as a Bugzilla::User object. |
| |
| =item C<requestee> |
| |
| Returns the user who has been requested to set the flag, as a |
| Bugzilla::User object. |
| |
| =item C<attachment> |
| |
| Returns the attachment object the flag belongs to if the flag |
| is an attachment flag, else undefined. |
| |
| =back |
| |
| =cut |
| |
| sub type { |
| my $self = shift; |
| |
| return $self->{'type'} ||= new Bugzilla::FlagType($self->{'type_id'}); |
| } |
| |
| sub setter { |
| my $self = shift; |
| |
| return $self->{'setter'} ||= new Bugzilla::User({ id => $self->{'setter_id'}, cache => 1 }); |
| } |
| |
| sub requestee { |
| my $self = shift; |
| |
| if (!defined $self->{'requestee'} && $self->{'requestee_id'}) { |
| $self->{'requestee'} = new Bugzilla::User({ id => $self->{'requestee_id'}, cache => 1 }); |
| } |
| return $self->{'requestee'}; |
| } |
| |
| sub attachment { |
| my $self = shift; |
| return undef unless $self->attach_id; |
| |
| require Bugzilla::Attachment; |
| return $self->{'attachment'} |
| ||= new Bugzilla::Attachment({ id => $self->attach_id, cache => 1 }); |
| } |
| |
| sub bug { |
| my $self = shift; |
| |
| require Bugzilla::Bug; |
| return $self->{'bug'} ||= new Bugzilla::Bug({ id => $self->bug_id, cache => 1 }); |
| } |
| |
| ################################ |
| ## Searching/Retrieving Flags ## |
| ################################ |
| |
| =pod |
| |
| =over |
| |
| =item C<match($criteria)> |
| |
| Queries the database for flags matching the given criteria |
| (specified as a hash of field names and their matching values) |
| and returns an array of matching records. |
| |
| =back |
| |
| =cut |
| |
| sub match { |
| my $class = shift; |
| my ($criteria) = @_; |
| |
| # If the caller specified only bug or attachment flags, |
| # limit the query to those kinds of flags. |
| if (my $type = delete $criteria->{'target_type'}) { |
| if ($type eq 'bug') { |
| $criteria->{'attach_id'} = IS_NULL; |
| } |
| elsif (!defined $criteria->{'attach_id'}) { |
| $criteria->{'attach_id'} = NOT_NULL; |
| } |
| } |
| # Flag->snapshot() calls Flag->match() with bug_id and attach_id |
| # as hash keys, even if attach_id is undefined. |
| if (exists $criteria->{'attach_id'} && !defined $criteria->{'attach_id'}) { |
| $criteria->{'attach_id'} = IS_NULL; |
| } |
| |
| return $class->SUPER::match(@_); |
| } |
| |
| =pod |
| |
| =over |
| |
| =item C<count($criteria)> |
| |
| Queries the database for flags matching the given criteria |
| (specified as a hash of field names and their matching values) |
| and returns an array of matching records. |
| |
| =back |
| |
| =cut |
| |
| sub count { |
| my $class = shift; |
| return scalar @{$class->match(@_)}; |
| } |
| |
| ###################################################################### |
| # Creating and Modifying |
| ###################################################################### |
| |
| sub set_flag { |
| my ($class, $obj, $params) = @_; |
| |
| my ($bug, $attachment, $obj_flag, $requestee_changed); |
| if (blessed($obj) && $obj->isa('Bugzilla::Attachment')) { |
| $attachment = $obj; |
| $bug = $attachment->bug; |
| } |
| elsif (blessed($obj) && $obj->isa('Bugzilla::Bug')) { |
| $bug = $obj; |
| } |
| else { |
| ThrowCodeError('flag_unexpected_object', { 'caller' => ref $obj }); |
| } |
| |
| # Make sure the user can change flags |
| my $privs; |
| $bug->check_can_change_field('flagtypes.name', 0, 1, \$privs) |
| || ThrowUserError('illegal_change', |
| { field => 'flagtypes.name', privs => $privs }); |
| |
| # Update (or delete) an existing flag. |
| if ($params->{id}) { |
| my $flag = $class->check({ id => $params->{id} }); |
| |
| # Security check: make sure the flag belongs to the bug/attachment. |
| # We don't check that the user editing the flag can see |
| # the bug/attachment. That's the job of the caller. |
| ($attachment && $flag->attach_id && $attachment->id == $flag->attach_id) |
| || (!$attachment && !$flag->attach_id && $bug->id == $flag->bug_id) |
| || ThrowCodeError('invalid_flag_association', |
| { bug_id => $bug->id, |
| attach_id => $attachment ? $attachment->id : undef }); |
| |
| # Extract the current flag object from the object. |
| my ($obj_flagtype) = grep { $_->id == $flag->type_id } @{$obj->flag_types}; |
| # If no flagtype can be found for this flag, this means the bug is being |
| # moved into a product/component where the flag is no longer valid. |
| # So either we can attach the flag to another flagtype having the same |
| # name, or we remove the flag. |
| if (!$obj_flagtype) { |
| my $success = $flag->retarget($obj); |
| return unless $success; |
| |
| ($obj_flagtype) = grep { $_->id == $flag->type_id } @{$obj->flag_types}; |
| push(@{$obj_flagtype->{flags}}, $flag); |
| } |
| ($obj_flag) = grep { $_->id == $flag->id } @{$obj_flagtype->{flags}}; |
| # If the flag has the correct type but cannot be found above, this means |
| # the flag is going to be removed (e.g. because this is a pending request |
| # and the attachment is being marked as obsolete). |
| return unless $obj_flag; |
| |
| ($obj_flag, $requestee_changed) = |
| $class->_validate($obj_flag, $obj_flagtype, $params, $bug, $attachment); |
| } |
| # Create a new flag. |
| elsif ($params->{type_id}) { |
| # Don't bother validating types the user didn't touch. |
| return if $params->{status} eq 'X'; |
| |
| my $flagtype = Bugzilla::FlagType->check({ id => $params->{type_id} }); |
| # Security check: make sure the flag type belongs to the bug/attachment. |
| ($attachment && $flagtype->target_type eq 'attachment' |
| && scalar(grep { $_->id == $flagtype->id } @{$attachment->flag_types})) |
| || (!$attachment && $flagtype->target_type eq 'bug' |
| && scalar(grep { $_->id == $flagtype->id } @{$bug->flag_types})) |
| || ThrowCodeError('invalid_flag_association', |
| { bug_id => $bug->id, |
| attach_id => $attachment ? $attachment->id : undef }); |
| |
| # Make sure the flag type is active. |
| $flagtype->is_active |
| || ThrowCodeError('flag_type_inactive', { type => $flagtype->name }); |
| |
| # Extract the current flagtype object from the object. |
| my ($obj_flagtype) = grep { $_->id == $flagtype->id } @{$obj->flag_types}; |
| |
| # We cannot create a new flag if there is already one and this |
| # flag type is not multiplicable. |
| if (!$flagtype->is_multiplicable) { |
| if (scalar @{$obj_flagtype->{flags}}) { |
| ThrowUserError('flag_type_not_multiplicable', { type => $flagtype }); |
| } |
| } |
| |
| ($obj_flag, $requestee_changed) = |
| $class->_validate(undef, $obj_flagtype, $params, $bug, $attachment); |
| } |
| else { |
| ThrowCodeError('param_required', { function => $class . '->set_flag', |
| param => 'id/type_id' }); |
| } |
| |
| if ($obj_flag |
| && $requestee_changed |
| && $obj_flag->requestee_id |
| && $obj_flag->requestee->setting('requestee_cc') eq 'on') |
| { |
| $bug->add_cc($obj_flag->requestee); |
| } |
| } |
| |
| sub _validate { |
| my ($class, $flag, $flag_type, $params, $bug, $attachment) = @_; |
| |
| # If it's a new flag, let's create it now. |
| my $obj_flag = $flag || bless({ type_id => $flag_type->id, |
| status => '', |
| bug_id => $bug->id, |
| attach_id => $attachment ? |
| $attachment->id : undef}, |
| $class); |
| |
| my $old_status = $obj_flag->status; |
| my $old_requestee_id = $obj_flag->requestee_id; |
| |
| $obj_flag->_set_status($params->{status}); |
| $obj_flag->_set_requestee($params->{requestee}, $bug, $attachment, $params->{skip_roe}); |
| |
| # The requestee ID can be undefined. |
| my $requestee_changed = ($obj_flag->requestee_id || 0) != ($old_requestee_id || 0); |
| |
| # The setter field MUST NOT be updated if neither the status |
| # nor the requestee fields changed. |
| if (($obj_flag->status ne $old_status) || $requestee_changed) { |
| $obj_flag->_set_setter($params->{setter}); |
| } |
| |
| # If the flag is deleted, remove it from the list. |
| if ($obj_flag->status eq 'X') { |
| @{$flag_type->{flags}} = grep { $_->id != $obj_flag->id } @{$flag_type->{flags}}; |
| return; |
| } |
| # Add the newly created flag to the list. |
| elsif (!$obj_flag->id) { |
| push(@{$flag_type->{flags}}, $obj_flag); |
| } |
| return wantarray ? ($obj_flag, $requestee_changed) : $obj_flag; |
| } |
| |
| =pod |
| |
| =over |
| |
| =item C<create($flag, $timestamp)> |
| |
| Creates a flag record in the database. |
| |
| =back |
| |
| =cut |
| |
| sub create { |
| my ($class, $flag, $timestamp) = @_; |
| $timestamp ||= Bugzilla->dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)'); |
| |
| my $params = {}; |
| my @columns = grep { $_ ne 'id' } $class->_get_db_columns; |
| |
| # Some columns use date formatting so use alias instead |
| @columns = map { /\s+AS\s+(.*)$/ ? $1 : $_ } @columns; |
| |
| $params->{$_} = $flag->{$_} foreach @columns; |
| |
| $params->{creation_date} = $params->{modification_date} = $timestamp; |
| |
| $flag = $class->SUPER::create($params); |
| return $flag; |
| } |
| |
| sub update { |
| my $self = shift; |
| my $dbh = Bugzilla->dbh; |
| my $timestamp = shift || $dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)'); |
| |
| my $changes = $self->SUPER::update(@_); |
| |
| if (scalar(keys %$changes)) { |
| $dbh->do('UPDATE flags SET modification_date = ? WHERE id = ?', |
| undef, ($timestamp, $self->id)); |
| $self->{'modification_date'} = |
| format_time($timestamp, '%Y.%m.%d %T', Bugzilla->local_timezone); |
| Bugzilla->memcached->clear({ table => 'flags', id => $self->id }); |
| } |
| return $changes; |
| } |
| |
| sub snapshot { |
| my ($class, $flags) = @_; |
| |
| my @summaries; |
| foreach my $flag (@$flags) { |
| my $summary = $flag->setter->nick . ':' . $flag->type->name . $flag->status; |
| $summary .= "(" . $flag->requestee->login . ")" if $flag->requestee; |
| push(@summaries, $summary); |
| } |
| return @summaries; |
| } |
| |
| sub update_activity { |
| my ($class, $old_summaries, $new_summaries) = @_; |
| |
| my ($removed, $added) = diff_arrays($old_summaries, $new_summaries); |
| if (scalar @$removed || scalar @$added) { |
| # Remove flag requester/setter information |
| foreach (@$removed, @$added) { s/^[^:]+:// } |
| |
| $removed = join(", ", @$removed); |
| $added = join(", ", @$added); |
| return ($removed, $added); |
| } |
| return (); |
| } |
| |
| sub update_flags { |
| my ($class, $self, $old_self, $timestamp) = @_; |
| |
| my @old_summaries = $class->snapshot($old_self->flags); |
| my %old_flags = map { $_->id => $_ } @{$old_self->flags}; |
| |
| foreach my $new_flag (@{$self->flags}) { |
| if (!$new_flag->id) { |
| # This is a new flag. |
| my $flag = $class->create($new_flag, $timestamp); |
| $new_flag->{id} = $flag->id; |
| $class->notify($new_flag, undef, $self, $timestamp); |
| } |
| else { |
| my $changes = $new_flag->update($timestamp); |
| if (scalar(keys %$changes)) { |
| $class->notify($new_flag, $old_flags{$new_flag->id}, $self, $timestamp); |
| } |
| delete $old_flags{$new_flag->id}; |
| } |
| } |
| # These flags have been deleted. |
| foreach my $old_flag (values %old_flags) { |
| $class->notify(undef, $old_flag, $self, $timestamp); |
| $old_flag->remove_from_db(); |
| } |
| |
| # If the bug has been moved into another product or component, |
| # we must also take care of attachment flags which are no longer valid, |
| # as well as all bug flags which haven't been forgotten above. |
| if ($self->isa('Bugzilla::Bug') |
| && ($self->{_old_product_name} || $self->{_old_component_name})) |
| { |
| my @removed = $class->force_cleanup($self); |
| push(@old_summaries, @removed); |
| } |
| |
| my @new_summaries = $class->snapshot($self->flags); |
| my @changes = $class->update_activity(\@old_summaries, \@new_summaries); |
| |
| Bugzilla::Hook::process('flag_end_of_update', { object => $self, |
| timestamp => $timestamp, |
| old_flags => \@old_summaries, |
| new_flags => \@new_summaries, |
| }); |
| return @changes; |
| } |
| |
| sub retarget { |
| my ($self, $obj) = @_; |
| |
| my @flagtypes = grep { $_->name eq $self->type->name } @{$obj->flag_types}; |
| |
| my $success = 0; |
| foreach my $flagtype (@flagtypes) { |
| next if !$flagtype->is_active; |
| next if (!$flagtype->is_multiplicable && scalar @{$flagtype->{flags}}); |
| next unless (($self->status eq '?' && $self->setter->can_request_flag($flagtype)) |
| || $self->setter->can_set_flag($flagtype)); |
| |
| $self->{type_id} = $flagtype->id; |
| delete $self->{type}; |
| $success = 1; |
| last; |
| } |
| return $success; |
| } |
| |
| # In case the bug's product/component has changed, clear flags that are |
| # no longer valid. |
| sub force_cleanup { |
| my ($class, $bug) = @_; |
| my $dbh = Bugzilla->dbh; |
| |
| my $flag_ids = $dbh->selectcol_arrayref( |
| 'SELECT DISTINCT flags.id |
| FROM flags |
| INNER JOIN bugs |
| ON flags.bug_id = bugs.bug_id |
| LEFT JOIN flaginclusions AS i |
| ON flags.type_id = i.type_id |
| AND (bugs.product_id = i.product_id OR i.product_id IS NULL) |
| AND (bugs.component_id = i.component_id OR i.component_id IS NULL) |
| WHERE bugs.bug_id = ? AND i.type_id IS NULL', |
| undef, $bug->id); |
| |
| my @removed = $class->force_retarget($flag_ids, $bug); |
| |
| $flag_ids = $dbh->selectcol_arrayref( |
| 'SELECT DISTINCT flags.id |
| FROM flags, bugs, flagexclusions e |
| WHERE bugs.bug_id = ? |
| AND flags.bug_id = bugs.bug_id |
| AND flags.type_id = e.type_id |
| AND (bugs.product_id = e.product_id OR e.product_id IS NULL) |
| AND (bugs.component_id = e.component_id OR e.component_id IS NULL)', |
| undef, $bug->id); |
| |
| push(@removed , $class->force_retarget($flag_ids, $bug)); |
| return @removed; |
| } |
| |
| sub force_retarget { |
| my ($class, $flag_ids, $bug) = @_; |
| my $dbh = Bugzilla->dbh; |
| |
| my $flags = $class->new_from_list($flag_ids); |
| my @removed; |
| foreach my $flag (@$flags) { |
| # $bug is undefined when e.g. editing inclusion and exclusion lists. |
| my $obj = $flag->attachment || $bug || $flag->bug; |
| my $is_retargetted = $flag->retarget($obj); |
| if ($is_retargetted) { |
| $dbh->do('UPDATE flags SET type_id = ? WHERE id = ?', |
| undef, ($flag->type_id, $flag->id)); |
| Bugzilla->memcached->clear({ table => 'flags', id => $flag->id }); |
| } |
| else { |
| # Track deleted attachment flags. |
| push(@removed, $class->snapshot([$flag])) if $flag->attach_id; |
| $class->notify(undef, $flag, $bug || $flag->bug); |
| $flag->remove_from_db(); |
| } |
| } |
| return @removed; |
| } |
| |
| ############################### |
| #### Validators ###### |
| ############################### |
| |
| sub _set_requestee { |
| my ($self, $requestee, $bug, $attachment, $skip_requestee_on_error) = @_; |
| |
| $self->{requestee} = |
| $self->_check_requestee($requestee, $bug, $attachment, $skip_requestee_on_error); |
| |
| $self->{requestee_id} = |
| $self->{requestee} ? $self->{requestee}->id : undef; |
| } |
| |
| sub _set_setter { |
| my ($self, $setter) = @_; |
| |
| $self->set('setter', $setter); |
| $self->{setter_id} = $self->setter->id; |
| } |
| |
| sub _set_status { |
| my ($self, $status) = @_; |
| |
| # Store the old flag status. It's needed by _check_setter(). |
| $self->{_old_status} = $self->status; |
| $self->set('status', $status); |
| } |
| |
| sub _check_requestee { |
| my ($self, $requestee, $bug, $attachment, $skip_requestee_on_error) = @_; |
| |
| # If the flag status is not "?", then no requestee can be defined. |
| return undef if ($self->status ne '?'); |
| |
| # Store this value before updating the flag object. |
| my $old_requestee = $self->requestee ? $self->requestee->login : ''; |
| |
| if ($self->status eq '?' && $requestee) { |
| $requestee = Bugzilla::User->check($requestee); |
| } |
| else { |
| undef $requestee; |
| } |
| |
| if ($requestee && $requestee->login ne $old_requestee) { |
| # Make sure the user didn't specify a requestee unless the flag |
| # is specifically requestable. For existing flags, if the requestee |
| # was set before the flag became specifically unrequestable, the |
| # user can either remove them or leave them alone. |
| ThrowUserError('flag_type_requestee_disabled', { type => $self->type }) |
| if !$self->type->is_requesteeble; |
| |
| # You can't ask a disabled account, as they don't have the ability to |
| # set the flag. |
| ThrowUserError('flag_requestee_disabled', { requestee => $requestee }) |
| if !$requestee->is_enabled; |
| |
| # Make sure the requestee can see the bug. |
| # Note that can_see_bug() will query the DB, so if the bug |
| # is being added/removed from some groups and these changes |
| # haven't been committed to the DB yet, they won't be taken |
| # into account here. In this case, old group restrictions matter. |
| # However, if the user has just been changed to the assignee, |
| # qa_contact, or added to the cc list of the bug and the bug |
| # is cclist_accessible, the requestee is allowed. |
| if (!$requestee->can_see_bug($self->bug_id) |
| && (!$bug->cclist_accessible |
| || !grep($_->id == $requestee->id, @{ $bug->cc_users }) |
| && $requestee->id != $bug->assigned_to->id |
| && (!$bug->qa_contact || $requestee->id != $bug->qa_contact->id))) |
| { |
| if ($skip_requestee_on_error) { |
| undef $requestee; |
| } |
| else { |
| ThrowUserError('flag_requestee_unauthorized', |
| { flag_type => $self->type, |
| requestee => $requestee, |
| bug_id => $self->bug_id, |
| attach_id => $self->attach_id }); |
| } |
| } |
| # Make sure the requestee can see the private attachment. |
| elsif ($self->attach_id && $attachment->isprivate && !$requestee->is_insider) { |
| if ($skip_requestee_on_error) { |
| undef $requestee; |
| } |
| else { |
| ThrowUserError('flag_requestee_unauthorized_attachment', |
| { flag_type => $self->type, |
| requestee => $requestee, |
| bug_id => $self->bug_id, |
| attach_id => $self->attach_id }); |
| } |
| } |
| # Make sure the user is allowed to set the flag. |
| elsif (!$requestee->can_set_flag($self->type)) { |
| if ($skip_requestee_on_error) { |
| undef $requestee; |
| } |
| else { |
| ThrowUserError('flag_requestee_needs_privs', |
| {'requestee' => $requestee, |
| 'flagtype' => $self->type}); |
| } |
| } |
| } |
| return $requestee; |
| } |
| |
| sub _check_setter { |
| my ($self, $setter) = @_; |
| |
| # By default, the currently logged in user is the setter. |
| $setter ||= Bugzilla->user; |
| (blessed($setter) && $setter->isa('Bugzilla::User') && $setter->id) |
| || ThrowUserError('invalid_user'); |
| |
| # set_status() has already been called. So this refers |
| # to the new flag status. |
| my $status = $self->status; |
| |
| # Make sure the user is authorized to modify flags, see bug 180879: |
| # - The flag exists and is unchanged. |
| # - The flag setter can unset flag. |
| # - Users in the request_group can clear pending requests and set flags |
| # and can rerequest set flags. |
| # - Users in the grant_group can set/clear flags, including "+" and "-". |
| unless (($status eq $self->{_old_status}) |
| || ($status eq 'X' && $setter->id == Bugzilla->user->id) |
| || (($status eq 'X' || $status eq '?') |
| && $setter->can_request_flag($self->type)) |
| || $setter->can_set_flag($self->type)) |
| { |
| ThrowUserError('flag_update_denied', |
| { name => $self->type->name, |
| status => $status, |
| old_status => $self->{_old_status} }); |
| } |
| |
| # If the request is being retargetted, we don't update |
| # the setter, so that the setter gets the notification. |
| if ($status eq '?' && $self->{_old_status} eq '?') { |
| return $self->setter; |
| } |
| return $setter; |
| } |
| |
| sub _check_status { |
| my ($self, $status) = @_; |
| |
| # - Make sure the status is valid. |
| # - Make sure the user didn't request the flag unless it's requestable. |
| # If the flag existed and was requested before it became unrequestable, |
| # leave it as is. |
| if (!grep($status eq $_ , qw(X + - ?)) |
| || ($status eq '?' && $self->status ne '?' && !$self->type->is_requestable)) |
| { |
| ThrowUserError('flag_status_invalid', { id => $self->id, |
| status => $status }); |
| } |
| return $status; |
| } |
| |
| ###################################################################### |
| # Utility Functions |
| ###################################################################### |
| |
| =pod |
| |
| =over |
| |
| =item C<extract_flags_from_cgi($bug, $attachment, $hr_vars)> |
| |
| Checks whether or not there are new flags to create and returns an |
| array of hashes. This array is then passed to Flag::create(). |
| |
| =back |
| |
| =cut |
| |
| sub extract_flags_from_cgi { |
| my ($class, $bug, $attachment, $vars, $skip) = @_; |
| my $cgi = Bugzilla->cgi; |
| |
| my $match_status = Bugzilla::User::match_field({ |
| '^requestee(_type)?-(\d+)$' => { 'type' => 'multi' }, |
| }, undef, $skip); |
| |
| $vars->{'match_field'} = 'requestee'; |
| if ($match_status == USER_MATCH_FAILED) { |
| $vars->{'message'} = 'user_match_failed'; |
| } |
| elsif ($match_status == USER_MATCH_MULTIPLE) { |
| $vars->{'message'} = 'user_match_multiple'; |
| } |
| |
| # Extract a list of flag type IDs from field names. |
| my @flagtype_ids = map(/^flag_type-(\d+)$/ ? $1 : (), $cgi->param()); |
| @flagtype_ids = grep($cgi->param("flag_type-$_") ne 'X', @flagtype_ids); |
| |
| # Extract a list of existing flag IDs. |
| my @flag_ids = map(/^flag-(\d+)$/ ? $1 : (), $cgi->param()); |
| |
| return ([], []) unless (scalar(@flagtype_ids) || scalar(@flag_ids)); |
| |
| my (@new_flags, @flags); |
| foreach my $flag_id (@flag_ids) { |
| my $flag = $class->new($flag_id); |
| # If the flag no longer exists, ignore it. |
| next unless $flag; |
| |
| my $status = $cgi->param("flag-$flag_id"); |
| |
| # If the user entered more than one name into the requestee field |
| # (i.e. they want more than one person to set the flag) we can reuse |
| # the existing flag for the first person (who may well be the existing |
| # requestee), but we have to create new flags for each additional requestee. |
| my @requestees = $cgi->param("requestee-$flag_id"); |
| my $requestee_email; |
| if ($status eq "?" |
| && scalar(@requestees) > 1 |
| && $flag->type->is_multiplicable) |
| { |
| # The first person, for which we'll reuse the existing flag. |
| $requestee_email = shift(@requestees); |
| |
| # Create new flags like the existing one for each additional person. |
| foreach my $login (@requestees) { |
| push(@new_flags, { type_id => $flag->type_id, |
| status => "?", |
| requestee => $login, |
| skip_roe => $skip }); |
| } |
| } |
| elsif ($status eq "?" && scalar(@requestees)) { |
| # If there are several requestees and the flag type is not multiplicable, |
| # this will fail. But that's the job of the validator to complain. All |
| # we do here is to extract and convert data from the CGI. |
| $requestee_email = trim($cgi->param("requestee-$flag_id") || ''); |
| } |
| |
| push(@flags, { id => $flag_id, |
| status => $status, |
| requestee => $requestee_email, |
| skip_roe => $skip }); |
| } |
| |
| # Get a list of active flag types available for this product/component. |
| my $flag_types = Bugzilla::FlagType::match( |
| { 'product_id' => $bug->{'product_id'}, |
| 'component_id' => $bug->{'component_id'}, |
| 'is_active' => 1 }); |
| |
| foreach my $flagtype_id (@flagtype_ids) { |
| # Checks if there are unexpected flags for the product/component. |
| if (!scalar(grep { $_->id == $flagtype_id } @$flag_types)) { |
| $vars->{'message'} = 'unexpected_flag_types'; |
| last; |
| } |
| } |
| |
| foreach my $flag_type (@$flag_types) { |
| my $type_id = $flag_type->id; |
| |
| # Bug flags are only valid for bugs, and attachment flags are |
| # only valid for attachments. So don't mix both. |
| next unless ($flag_type->target_type eq 'bug' xor $attachment); |
| |
| # We are only interested in flags the user tries to create. |
| next unless scalar(grep { $_ == $type_id } @flagtype_ids); |
| |
| # Get the number of flags of this type already set for this target. |
| my $has_flags = $class->count( |
| { 'type_id' => $type_id, |
| 'target_type' => $attachment ? 'attachment' : 'bug', |
| 'bug_id' => $bug->bug_id, |
| 'attach_id' => $attachment ? $attachment->id : undef }); |
| |
| # Do not create a new flag of this type if this flag type is |
| # not multiplicable and already has a flag set. |
| next if (!$flag_type->is_multiplicable && $has_flags); |
| |
| my $status = $cgi->param("flag_type-$type_id"); |
| trick_taint($status); |
| |
| my @logins = $cgi->param("requestee_type-$type_id"); |
| if ($status eq "?" && scalar(@logins)) { |
| foreach my $login (@logins) { |
| push (@new_flags, { type_id => $type_id, |
| status => $status, |
| requestee => $login, |
| skip_roe => $skip }); |
| last unless $flag_type->is_multiplicable; |
| } |
| } |
| else { |
| push (@new_flags, { type_id => $type_id, |
| status => $status }); |
| } |
| } |
| |
| # Return the list of flags to update and/or to create. |
| return (\@flags, \@new_flags); |
| } |
| |
| =pod |
| |
| =over |
| |
| =item C<multi_extract_flags_from_cgi($bug, $hr_vars)> |
| |
| Checks whether or not there are new flags to create and returns an |
| array of hashes. This array is then passed to Flag::create(). This differs |
| from the previous sub-routine as it is called for changing multiple bugs |
| |
| =back |
| |
| =cut |
| |
| sub multi_extract_flags_from_cgi { |
| my ($class, $bug, $vars, $skip) = @_; |
| my $cgi = Bugzilla->cgi; |
| |
| my $match_status = Bugzilla::User::match_field({ |
| '^requestee(_type)?-(\d+)$' => { 'type' => 'multi' }, |
| }, undef, $skip); |
| |
| $vars->{'match_field'} = 'requestee'; |
| if ($match_status == USER_MATCH_FAILED) { |
| $vars->{'message'} = 'user_match_failed'; |
| } |
| elsif ($match_status == USER_MATCH_MULTIPLE) { |
| $vars->{'message'} = 'user_match_multiple'; |
| } |
| |
| # Extract a list of flag type IDs from field names. |
| my @flagtype_ids = map(/^flag_type-(\d+)$/ ? $1 : (), $cgi->param()); |
| |
| my (@new_flags, @flags); |
| |
| # Get a list of active flag types available for this product/component. |
| my $flag_types = Bugzilla::FlagType::match( |
| { 'product_id' => $bug->{'product_id'}, |
| 'component_id' => $bug->{'component_id'}, |
| 'is_active' => 1 }); |
| |
| foreach my $flagtype_id (@flagtype_ids) { |
| # Checks if there are unexpected flags for the product/component. |
| if (!scalar(grep { $_->id == $flagtype_id } @$flag_types)) { |
| $vars->{'message'} = 'unexpected_flag_types'; |
| last; |
| } |
| } |
| |
| foreach my $flag_type (@$flag_types) { |
| my $type_id = $flag_type->id; |
| |
| # Bug flags are only valid for bugs |
| next unless ($flag_type->target_type eq 'bug'); |
| |
| # We are only interested in flags the user tries to create. |
| next unless scalar(grep { $_ == $type_id } @flagtype_ids); |
| |
| # Get the flags of this type already set for this bug. |
| my $current_flags = $class->match( |
| { 'type_id' => $type_id, |
| 'target_type' => 'bug', |
| 'bug_id' => $bug->bug_id }); |
| |
| # We will update existing flags (instead of creating new ones) |
| # if the flag exists and the user has not chosen the 'always add' |
| # option |
| my $update = scalar(@$current_flags) && ! $cgi->param("flags_add-$type_id"); |
| |
| my $status = $cgi->param("flag_type-$type_id"); |
| trick_taint($status); |
| |
| my @logins = $cgi->param("requestee_type-$type_id"); |
| if ($status eq "?" && scalar(@logins)) { |
| foreach my $login (@logins) { |
| if ($update) { |
| foreach my $current_flag (@$current_flags) { |
| push (@flags, { id => $current_flag->id, |
| status => $status, |
| requestee => $login, |
| skip_roe => $skip }); |
| } |
| } |
| else { |
| push (@new_flags, { type_id => $type_id, |
| status => $status, |
| requestee => $login, |
| skip_roe => $skip }); |
| } |
| |
| last unless $flag_type->is_multiplicable; |
| } |
| } |
| else { |
| if ($update) { |
| foreach my $current_flag (@$current_flags) { |
| push (@flags, { id => $current_flag->id, |
| status => $status }); |
| } |
| } |
| else { |
| push (@new_flags, { type_id => $type_id, |
| status => $status }); |
| } |
| } |
| } |
| |
| # Return the list of flags to update and/or to create. |
| return (\@flags, \@new_flags); |
| } |
| |
| =pod |
| |
| =over |
| |
| =item C<notify($flag, $old_flag, $object, $timestamp)> |
| |
| Sends an email notification about a flag being created, fulfilled |
| or deleted. |
| |
| =back |
| |
| =cut |
| |
| sub notify { |
| my ($class, $flag, $old_flag, $obj, $timestamp) = @_; |
| |
| my ($bug, $attachment); |
| if (blessed($obj) && $obj->isa('Bugzilla::Attachment')) { |
| $attachment = $obj; |
| $bug = $attachment->bug; |
| } |
| elsif (blessed($obj) && $obj->isa('Bugzilla::Bug')) { |
| $bug = $obj; |
| } |
| else { |
| # Not a good time to throw an error. |
| return; |
| } |
| |
| my $addressee; |
| # If the flag is set to '?', maybe the requestee wants a notification. |
| if ($flag && $flag->requestee_id |
| && (!$old_flag || ($old_flag->requestee_id || 0) != $flag->requestee_id)) |
| { |
| if ($flag->requestee->wants_mail([EVT_FLAG_REQUESTED])) { |
| $addressee = $flag->requestee; |
| } |
| } |
| elsif ($old_flag && $old_flag->status eq '?' |
| && (!$flag || $flag->status ne '?')) |
| { |
| if ($old_flag->setter->wants_mail([EVT_REQUESTED_FLAG])) { |
| $addressee = $old_flag->setter; |
| } |
| } |
| |
| my $cc_list = $flag ? $flag->type->cc_list : $old_flag->type->cc_list; |
| # Is there someone to notify? |
| return unless ($addressee || $cc_list); |
| |
| # The email client will display the Date: header in the desired timezone, |
| # so we can always use UTC here. |
| $timestamp ||= Bugzilla->dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)'); |
| $timestamp = format_time($timestamp, '%a, %d %b %Y %T %z', 'UTC'); |
| |
| # If the target bug is restricted to one or more groups, then we need |
| # to make sure we don't send email about it to unauthorized users |
| # on the request type's CC: list, so we have to trawl the list for users |
| # not in those groups or email addresses that don't have an account. |
| my @bug_in_groups = grep {$_->{'ison'} || $_->{'mandatory'}} @{$bug->groups}; |
| my $attachment_is_private = $attachment ? $attachment->isprivate : undef; |
| |
| my %recipients; |
| foreach my $cc (split(/[, ]+/, $cc_list)) { |
| my $ccuser = new Bugzilla::User({ name => $cc }); |
| next if (scalar(@bug_in_groups) && (!$ccuser || !$ccuser->can_see_bug($bug->bug_id))); |
| next if $attachment_is_private && (!$ccuser || !$ccuser->is_insider); |
| # Prevent duplicated entries due to case sensitivity. |
| $cc = $ccuser ? $ccuser->email : $cc; |
| $recipients{$cc} = $ccuser; |
| } |
| |
| # Only notify if the addressee is allowed to receive the email. |
| if ($addressee && $addressee->email_enabled) { |
| $recipients{$addressee->email} = $addressee; |
| } |
| # Process and send notification for each recipient. |
| # If there are users in the CC list who don't have an account, |
| # use the default language for email notifications. |
| my $default_lang; |
| if (grep { !$_ } values %recipients) { |
| $default_lang = Bugzilla::User->new()->setting('lang'); |
| } |
| |
| # Get comments on the bug |
| my $all_comments = $bug->comments({ after => $bug->lastdiffed }); |
| @$all_comments = grep { $_->type || $_->body =~ /\S/ } @$all_comments; |
| |
| # Get public only comments |
| my $public_comments = [ grep { !$_->is_private } @$all_comments ]; |
| |
| foreach my $to (keys %recipients) { |
| # Add threadingmarker to allow flag notification emails to be the |
| # threaded similar to normal bug change emails. |
| my $thread_user_id = $recipients{$to} ? $recipients{$to}->id : 0; |
| |
| # We only want to show private comments to users in the is_insider group |
| my $comments = $recipients{$to} && $recipients{$to}->is_insider |
| ? $all_comments : $public_comments; |
| |
| my $vars = { |
| flag => $flag, |
| old_flag => $old_flag, |
| to => $to, |
| date => $timestamp, |
| bug => $bug, |
| attachment => $attachment, |
| threadingmarker => build_thread_marker($bug->id, $thread_user_id), |
| new_comments => $comments, |
| }; |
| |
| my $lang = $recipients{$to} ? |
| $recipients{$to}->setting('lang') : $default_lang; |
| |
| my $template = Bugzilla->template_inner($lang); |
| my $message; |
| $template->process("email/flagmail.txt.tmpl", $vars, \$message) |
| || ThrowTemplateError($template->error()); |
| |
| MessageToMTA($message); |
| } |
| } |
| |
| # This is an internal function used by $bug->flag_types |
| # and $attachment->flag_types to collect data about available |
| # flag types and existing flags set on them. You should never |
| # call this function directly. |
| sub _flag_types { |
| my ($class, $vars) = @_; |
| |
| my $target_type = $vars->{target_type}; |
| my $flags; |
| |
| # Retrieve all existing flags for this bug/attachment. |
| if ($target_type eq 'bug') { |
| my $bug_id = delete $vars->{bug_id}; |
| $flags = $class->match({target_type => 'bug', bug_id => $bug_id}); |
| } |
| elsif ($target_type eq 'attachment') { |
| my $attach_id = delete $vars->{attach_id}; |
| $flags = $class->match({attach_id => $attach_id}); |
| } |
| else { |
| ThrowCodeError('bad_arg', {argument => 'target_type', |
| function => $class . '->_flag_types'}); |
| } |
| |
| # Get all available flag types for the given product and component. |
| my $cache = Bugzilla->request_cache->{flag_types_per_component}->{$vars->{target_type}} ||= {}; |
| my $flag_data = $cache->{$vars->{component_id}} ||= Bugzilla::FlagType::match($vars); |
| my $flag_types = dclone($flag_data); |
| |
| $_->{flags} = [] foreach @$flag_types; |
| my %flagtypes = map { $_->id => $_ } @$flag_types; |
| |
| # Group existing flags per type, and skip those becoming invalid |
| # (which can happen when a bug is being moved into a new product |
| # or component). |
| @$flags = grep { exists $flagtypes{$_->type_id} } @$flags; |
| push(@{$flagtypes{$_->type_id}->{flags}}, $_) foreach @$flags; |
| return $flag_types; |
| } |
| |
| 1; |
| |
| =head1 B<Methods in need of POD> |
| |
| =over |
| |
| =item update_activity |
| |
| =item setter_id |
| |
| =item bug |
| |
| =item requestee_id |
| |
| =item DB_COLUMNS |
| |
| =item set_flag |
| |
| =item type_id |
| |
| =item snapshot |
| |
| =item update_flags |
| |
| =item update |
| |
| =back |
