aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat (limited to 'Bugzilla/Bug.pm')
-rw-r--r--Bugzilla/Bug.pm7336
1 files changed, 3770 insertions, 3566 deletions
diff --git a/Bugzilla/Bug.pm b/Bugzilla/Bug.pm
index 8b4493f85..b6b44b262 100644
--- a/Bugzilla/Bug.pm
+++ b/Bugzilla/Bug.pm
@@ -38,9 +38,9 @@ use Scalar::Util qw(blessed);
use parent qw(Bugzilla::Object Exporter);
@Bugzilla::Bug::EXPORT = qw(
- bug_alias_to_id
- LogActivityEntry
- editable_bug_fields
+ bug_alias_to_id
+ LogActivityEntry
+ editable_bug_fields
);
#####################################################################
@@ -51,198 +51,199 @@ use constant DB_TABLE => 'bugs';
use constant ID_FIELD => 'bug_id';
use constant NAME_FIELD => 'bug_id';
use constant LIST_ORDER => ID_FIELD;
+
# Bugs have their own auditing table, bugs_activity.
use constant AUDIT_CREATES => 0;
use constant AUDIT_UPDATES => 0;
+
# This will be enabled later
use constant USE_MEMCACHED => 0;
# This is a sub because it needs to call other subroutines.
sub DB_COLUMNS {
- my $dbh = Bugzilla->dbh;
- my @custom = grep {$_->type != FIELD_TYPE_MULTI_SELECT}
- Bugzilla->active_custom_fields;
- my @custom_names = map {$_->name} @custom;
-
- my @columns = (qw(
- assigned_to
- bug_file_loc
- bug_id
- bug_severity
- bug_status
- cclist_accessible
- component_id
- creation_ts
- delta_ts
- estimated_time
- everconfirmed
- lastdiffed
- op_sys
- priority
- product_id
- qa_contact
- remaining_time
- rep_platform
- reporter_accessible
- resolution
- short_desc
- status_whiteboard
- target_milestone
- version
- ),
- 'reporter AS reporter_id',
- $dbh->sql_date_format('deadline', '%Y-%m-%d') . ' AS deadline',
- @custom_names);
-
- Bugzilla::Hook::process("bug_columns", { columns => \@columns });
-
- return @columns;
+ my $dbh = Bugzilla->dbh;
+ my @custom
+ = grep { $_->type != FIELD_TYPE_MULTI_SELECT } Bugzilla->active_custom_fields;
+ my @custom_names = map { $_->name } @custom;
+
+ my @columns = (
+ qw(
+ assigned_to
+ bug_file_loc
+ bug_id
+ bug_severity
+ bug_status
+ cclist_accessible
+ component_id
+ creation_ts
+ delta_ts
+ estimated_time
+ everconfirmed
+ lastdiffed
+ op_sys
+ priority
+ product_id
+ qa_contact
+ remaining_time
+ rep_platform
+ reporter_accessible
+ resolution
+ short_desc
+ status_whiteboard
+ target_milestone
+ version
+ ), 'reporter AS reporter_id',
+ $dbh->sql_date_format('deadline', '%Y-%m-%d') . ' AS deadline', @custom_names
+ );
+
+ Bugzilla::Hook::process("bug_columns", {columns => \@columns});
+
+ return @columns;
}
sub VALIDATORS {
- my $validators = {
- alias => \&_check_alias,
- assigned_to => \&_check_assigned_to,
- blocked => \&_check_dependencies,
- bug_file_loc => \&_check_bug_file_loc,
- bug_severity => \&_check_select_field,
- bug_status => \&_check_bug_status,
- cc => \&_check_cc,
- comment => \&_check_comment,
- component => \&_check_component,
- creation_ts => \&_check_creation_ts,
- deadline => \&_check_deadline,
- dependson => \&_check_dependencies,
- dup_id => \&_check_dup_id,
- estimated_time => \&_check_time_field,
- everconfirmed => \&Bugzilla::Object::check_boolean,
- groups => \&_check_groups,
- keywords => \&_check_keywords,
- op_sys => \&_check_select_field,
- priority => \&_check_priority,
- product => \&_check_product,
- qa_contact => \&_check_qa_contact,
- remaining_time => \&_check_time_field,
- rep_platform => \&_check_select_field,
- resolution => \&_check_resolution,
- short_desc => \&_check_short_desc,
- status_whiteboard => \&_check_status_whiteboard,
- target_milestone => \&_check_target_milestone,
- version => \&_check_version,
-
- cclist_accessible => \&Bugzilla::Object::check_boolean,
- reporter_accessible => \&Bugzilla::Object::check_boolean,
- };
-
- # Set up validators for custom fields.
- foreach my $field (Bugzilla->active_custom_fields) {
- my $validator;
- if ($field->type == FIELD_TYPE_SINGLE_SELECT) {
- $validator = \&_check_select_field;
- }
- elsif ($field->type == FIELD_TYPE_MULTI_SELECT) {
- $validator = \&_check_multi_select_field;
- }
- elsif ($field->type == FIELD_TYPE_DATETIME) {
- $validator = \&_check_datetime_field;
- }
- elsif ($field->type == FIELD_TYPE_DATE) {
- $validator = \&_check_date_field;
- }
- elsif ($field->type == FIELD_TYPE_FREETEXT) {
- $validator = \&_check_freetext_field;
- }
- elsif ($field->type == FIELD_TYPE_BUG_ID) {
- $validator = \&_check_bugid_field;
- }
- elsif ($field->type == FIELD_TYPE_TEXTAREA) {
- $validator = \&_check_textarea_field;
- }
- elsif ($field->type == FIELD_TYPE_INTEGER) {
- $validator = \&_check_integer_field;
- }
- else {
- $validator = \&_check_default_field;
- }
- $validators->{$field->name} = $validator;
+ my $validators = {
+ alias => \&_check_alias,
+ assigned_to => \&_check_assigned_to,
+ blocked => \&_check_dependencies,
+ bug_file_loc => \&_check_bug_file_loc,
+ bug_severity => \&_check_select_field,
+ bug_status => \&_check_bug_status,
+ cc => \&_check_cc,
+ comment => \&_check_comment,
+ component => \&_check_component,
+ creation_ts => \&_check_creation_ts,
+ deadline => \&_check_deadline,
+ dependson => \&_check_dependencies,
+ dup_id => \&_check_dup_id,
+ estimated_time => \&_check_time_field,
+ everconfirmed => \&Bugzilla::Object::check_boolean,
+ groups => \&_check_groups,
+ keywords => \&_check_keywords,
+ op_sys => \&_check_select_field,
+ priority => \&_check_priority,
+ product => \&_check_product,
+ qa_contact => \&_check_qa_contact,
+ remaining_time => \&_check_time_field,
+ rep_platform => \&_check_select_field,
+ resolution => \&_check_resolution,
+ short_desc => \&_check_short_desc,
+ status_whiteboard => \&_check_status_whiteboard,
+ target_milestone => \&_check_target_milestone,
+ version => \&_check_version,
+
+ cclist_accessible => \&Bugzilla::Object::check_boolean,
+ reporter_accessible => \&Bugzilla::Object::check_boolean,
+ };
+
+ # Set up validators for custom fields.
+ foreach my $field (Bugzilla->active_custom_fields) {
+ my $validator;
+ if ($field->type == FIELD_TYPE_SINGLE_SELECT) {
+ $validator = \&_check_select_field;
+ }
+ elsif ($field->type == FIELD_TYPE_MULTI_SELECT) {
+ $validator = \&_check_multi_select_field;
+ }
+ elsif ($field->type == FIELD_TYPE_DATETIME) {
+ $validator = \&_check_datetime_field;
+ }
+ elsif ($field->type == FIELD_TYPE_DATE) {
+ $validator = \&_check_date_field;
+ }
+ elsif ($field->type == FIELD_TYPE_FREETEXT) {
+ $validator = \&_check_freetext_field;
+ }
+ elsif ($field->type == FIELD_TYPE_BUG_ID) {
+ $validator = \&_check_bugid_field;
+ }
+ elsif ($field->type == FIELD_TYPE_TEXTAREA) {
+ $validator = \&_check_textarea_field;
+ }
+ elsif ($field->type == FIELD_TYPE_INTEGER) {
+ $validator = \&_check_integer_field;
+ }
+ else {
+ $validator = \&_check_default_field;
}
+ $validators->{$field->name} = $validator;
+ }
- return $validators;
-};
+ return $validators;
+}
sub VALIDATOR_DEPENDENCIES {
- my $cache = Bugzilla->request_cache;
- return $cache->{bug_validator_dependencies}
- if $cache->{bug_validator_dependencies};
-
- my %deps = (
- assigned_to => ['component'],
- blocked => ['product'],
- bug_status => ['product', 'comment', 'target_milestone'],
- cc => ['component'],
- comment => ['creation_ts'],
- component => ['product'],
- dependson => ['product'],
- dup_id => ['bug_status', 'resolution'],
- groups => ['product'],
- keywords => ['product'],
- resolution => ['bug_status', 'dependson'],
- qa_contact => ['component'],
- target_milestone => ['product'],
- version => ['product'],
- );
-
- foreach my $field (@{ Bugzilla->fields }) {
- $deps{$field->name} = [ $field->visibility_field->name ]
- if $field->{visibility_field_id};
- }
-
- $cache->{bug_validator_dependencies} = \%deps;
- return \%deps;
-};
+ my $cache = Bugzilla->request_cache;
+ return $cache->{bug_validator_dependencies}
+ if $cache->{bug_validator_dependencies};
+
+ my %deps = (
+ assigned_to => ['component'],
+ blocked => ['product'],
+ bug_status => ['product', 'comment', 'target_milestone'],
+ cc => ['component'],
+ comment => ['creation_ts'],
+ component => ['product'],
+ dependson => ['product'],
+ dup_id => ['bug_status', 'resolution'],
+ groups => ['product'],
+ keywords => ['product'],
+ resolution => ['bug_status', 'dependson'],
+ qa_contact => ['component'],
+ target_milestone => ['product'],
+ version => ['product'],
+ );
+
+ foreach my $field (@{Bugzilla->fields}) {
+ $deps{$field->name} = [$field->visibility_field->name]
+ if $field->{visibility_field_id};
+ }
+
+ $cache->{bug_validator_dependencies} = \%deps;
+ return \%deps;
+}
sub UPDATE_COLUMNS {
- my @custom = grep {$_->type != FIELD_TYPE_MULTI_SELECT}
- Bugzilla->active_custom_fields;
- my @custom_names = map {$_->name} @custom;
- my @columns = qw(
- assigned_to
- bug_file_loc
- bug_severity
- bug_status
- cclist_accessible
- component_id
- deadline
- estimated_time
- everconfirmed
- op_sys
- priority
- product_id
- qa_contact
- remaining_time
- rep_platform
- reporter_accessible
- resolution
- short_desc
- status_whiteboard
- target_milestone
- version
- );
- push(@columns, @custom_names);
- return @columns;
-};
-
-use constant NUMERIC_COLUMNS => qw(
+ my @custom
+ = grep { $_->type != FIELD_TYPE_MULTI_SELECT } Bugzilla->active_custom_fields;
+ my @custom_names = map { $_->name } @custom;
+ my @columns = qw(
+ assigned_to
+ bug_file_loc
+ bug_severity
+ bug_status
+ cclist_accessible
+ component_id
+ deadline
estimated_time
+ everconfirmed
+ op_sys
+ priority
+ product_id
+ qa_contact
remaining_time
+ rep_platform
+ reporter_accessible
+ resolution
+ short_desc
+ status_whiteboard
+ target_milestone
+ version
+ );
+ push(@columns, @custom_names);
+ return @columns;
+}
+
+use constant NUMERIC_COLUMNS => qw(
+ estimated_time
+ remaining_time
);
sub DATE_COLUMNS {
- my @fields = (@{ Bugzilla->fields({ type => [FIELD_TYPE_DATETIME,
- FIELD_TYPE_DATE] })
- });
- return map { $_->name } @fields;
+ my @fields
+ = (@{Bugzilla->fields({type => [FIELD_TYPE_DATETIME, FIELD_TYPE_DATE]})});
+ return map { $_->name } @fields;
}
# Used in LogActivityEntry(). Gives the max length of lines in the
@@ -254,30 +255,28 @@ use constant MAX_LINE_LENGTH => 254;
# of Bugzilla. (These are the field names that the WebService and email_in.pl
# use.)
use constant FIELD_MAP => {
- blocks => 'blocked',
- commentprivacy => 'comment_is_private',
- creation_time => 'creation_ts',
- creator => 'reporter',
- description => 'comment',
- depends_on => 'dependson',
- dupe_of => 'dup_id',
- id => 'bug_id',
- is_confirmed => 'everconfirmed',
- is_cc_accessible => 'cclist_accessible',
- is_creator_accessible => 'reporter_accessible',
- last_change_time => 'delta_ts',
- platform => 'rep_platform',
- severity => 'bug_severity',
- status => 'bug_status',
- summary => 'short_desc',
- url => 'bug_file_loc',
- whiteboard => 'status_whiteboard',
+ blocks => 'blocked',
+ commentprivacy => 'comment_is_private',
+ creation_time => 'creation_ts',
+ creator => 'reporter',
+ description => 'comment',
+ depends_on => 'dependson',
+ dupe_of => 'dup_id',
+ id => 'bug_id',
+ is_confirmed => 'everconfirmed',
+ is_cc_accessible => 'cclist_accessible',
+ is_creator_accessible => 'reporter_accessible',
+ last_change_time => 'delta_ts',
+ platform => 'rep_platform',
+ severity => 'bug_severity',
+ status => 'bug_status',
+ summary => 'short_desc',
+ url => 'bug_file_loc',
+ whiteboard => 'status_whiteboard',
};
-use constant REQUIRED_FIELD_MAP => {
- product_id => 'product',
- component_id => 'component',
-};
+use constant REQUIRED_FIELD_MAP =>
+ {product_id => 'product', component_id => 'component',};
# Creation timestamp is here because it needs to be validated
# but it can be NULL in the database (see comments in create above)
@@ -295,360 +294,374 @@ use constant REQUIRED_FIELD_MAP => {
#
# Groups are in a separate table, but must always be validated so that
# mandatory groups get set on bugs.
-use constant EXTRA_REQUIRED_FIELDS => qw(creation_ts target_milestone cc qa_contact groups);
+use constant EXTRA_REQUIRED_FIELDS =>
+ qw(creation_ts target_milestone cc qa_contact groups);
#####################################################################
sub new {
- my $invocant = shift;
- my $class = ref($invocant) || $invocant;
- my $param = shift;
-
- # Remove leading "#" mark if we've just been passed an id.
- if (!ref $param && $param =~ /^#([0-9]+)$/) {
- $param = $1;
- }
-
- # If we get something that looks like a word (not a number),
- # make it the "name" param.
- if (!defined $param
- || (!ref($param) && $param !~ /^[0-9]+$/)
- || (ref($param) && $param->{id} !~ /^[0-9]+$/))
- {
- if ($param) {
- my $alias = ref($param) ? $param->{id} : $param;
- my $bug_id = bug_alias_to_id($alias);
- if (! $bug_id) {
- my $error_self = {};
- bless $error_self, $class;
- $error_self->{'bug_id'} = $alias;
- $error_self->{'error'} = 'InvalidBugId';
- return $error_self;
- }
- $param = { id => $bug_id,
- cache => ref($param) ? $param->{cache} : 0 };
- }
- else {
- # We got something that's not a number.
- my $error_self = {};
- bless $error_self, $class;
- $error_self->{'bug_id'} = $param;
- $error_self->{'error'} = 'InvalidBugId';
- return $error_self;
- }
- }
-
- unshift @_, $param;
- my $self = $class->SUPER::new(@_);
-
- # Bugzilla::Bug->new always returns something, but sets $self->{error}
- # if the bug wasn't found in the database.
- if (!$self) {
+ my $invocant = shift;
+ my $class = ref($invocant) || $invocant;
+ my $param = shift;
+
+ # Remove leading "#" mark if we've just been passed an id.
+ if (!ref $param && $param =~ /^#([0-9]+)$/) {
+ $param = $1;
+ }
+
+ # If we get something that looks like a word (not a number),
+ # make it the "name" param.
+ if ( !defined $param
+ || (!ref($param) && $param !~ /^[0-9]+$/)
+ || (ref($param) && $param->{id} !~ /^[0-9]+$/))
+ {
+ if ($param) {
+ my $alias = ref($param) ? $param->{id} : $param;
+ my $bug_id = bug_alias_to_id($alias);
+ if (!$bug_id) {
my $error_self = {};
- if (ref $param) {
- $error_self->{bug_id} = $param->{name};
- $error_self->{error} = 'InvalidBugId';
- }
- else {
- $error_self->{bug_id} = $param;
- $error_self->{error} = 'NotFound';
- }
bless $error_self, $class;
+ $error_self->{'bug_id'} = $alias;
+ $error_self->{'error'} = 'InvalidBugId';
return $error_self;
+ }
+ $param = {id => $bug_id, cache => ref($param) ? $param->{cache} : 0};
+ }
+ else {
+ # We got something that's not a number.
+ my $error_self = {};
+ bless $error_self, $class;
+ $error_self->{'bug_id'} = $param;
+ $error_self->{'error'} = 'InvalidBugId';
+ return $error_self;
+ }
+ }
+
+ unshift @_, $param;
+ my $self = $class->SUPER::new(@_);
+
+ # Bugzilla::Bug->new always returns something, but sets $self->{error}
+ # if the bug wasn't found in the database.
+ if (!$self) {
+ my $error_self = {};
+ if (ref $param) {
+ $error_self->{bug_id} = $param->{name};
+ $error_self->{error} = 'InvalidBugId';
+ }
+ else {
+ $error_self->{bug_id} = $param;
+ $error_self->{error} = 'NotFound';
}
+ bless $error_self, $class;
+ return $error_self;
+ }
- return $self;
+ return $self;
}
sub initialize {
- $_[0]->_create_cf_accessors();
+ $_[0]->_create_cf_accessors();
}
sub object_cache_key {
- my $class = shift;
- my $key = $class->SUPER::object_cache_key(@_)
- || return;
- return $key . ',' . Bugzilla->user->id;
+ my $class = shift;
+ my $key = $class->SUPER::object_cache_key(@_) || return;
+ return $key . ',' . Bugzilla->user->id;
}
sub check {
- my $class = shift;
- my ($param, $field) = @_;
+ my $class = shift;
+ my ($param, $field) = @_;
- # Bugzilla::Bug throws lots of special errors, so we don't call
- # SUPER::check, we just call our new and do our own checks.
- my $id = ref($param)
- ? ($param->{id} = trim($param->{id}))
- : ($param = trim($param));
- ThrowUserError('improper_bug_id_field_value', { field => $field }) unless defined $id;
+ # Bugzilla::Bug throws lots of special errors, so we don't call
+ # SUPER::check, we just call our new and do our own checks.
+ my $id
+ = ref($param) ? ($param->{id} = trim($param->{id})) : ($param = trim($param));
+ ThrowUserError('improper_bug_id_field_value', {field => $field})
+ unless defined $id;
- my $self = $class->new($param);
+ my $self = $class->new($param);
- if ($self->{error}) {
- # For error messages, use the id that was returned by new(), because
- # it's cleaned up.
- $id = $self->id;
+ if ($self->{error}) {
- if ($self->{error} eq 'NotFound') {
- ThrowUserError("bug_id_does_not_exist", { bug_id => $id });
- }
- if ($self->{error} eq 'InvalidBugId') {
- ThrowUserError("improper_bug_id_field_value",
- { bug_id => $id,
- field => $field });
- }
- }
+ # For error messages, use the id that was returned by new(), because
+ # it's cleaned up.
+ $id = $self->id;
- unless ($field && $field =~ /^(dependson|blocked|dup_id)$/) {
- $self->check_is_visible($id);
+ if ($self->{error} eq 'NotFound') {
+ ThrowUserError("bug_id_does_not_exist", {bug_id => $id});
}
- return $self;
+ if ($self->{error} eq 'InvalidBugId') {
+ ThrowUserError("improper_bug_id_field_value", {bug_id => $id, field => $field});
+ }
+ }
+
+ unless ($field && $field =~ /^(dependson|blocked|dup_id)$/) {
+ $self->check_is_visible($id);
+ }
+ return $self;
}
sub check_for_edit {
- my $class = shift;
- my $bug = $class->check(@_);
+ my $class = shift;
+ my $bug = $class->check(@_);
- Bugzilla->user->can_edit_product($bug->product_id)
- || ThrowUserError("product_edit_denied", { product => $bug->product });
+ Bugzilla->user->can_edit_product($bug->product_id)
+ || ThrowUserError("product_edit_denied", {product => $bug->product});
- return $bug;
+ return $bug;
}
sub check_is_visible {
- my ($self, $input_id) = @_;
- $input_id ||= $self->id;
- my $user = Bugzilla->user;
+ my ($self, $input_id) = @_;
+ $input_id ||= $self->id;
+ my $user = Bugzilla->user;
- if (!$user->can_see_bug($self->id)) {
- # The error the user sees depends on whether or not they are
- # logged in (i.e. $user->id contains the user's positive integer ID).
- # If we are validating an alias, then use it in the error message
- # instead of its corresponding bug ID, to not disclose it.
- if ($user->id) {
- ThrowUserError("bug_access_denied", { bug_id => $input_id });
- } else {
- ThrowUserError("bug_access_query", { bug_id => $input_id });
- }
- }
-}
+ if (!$user->can_see_bug($self->id)) {
-sub match {
- my $class = shift;
- my ($params) = @_;
-
- # Allow matching certain fields by name (in addition to matching by ID).
- my %translate_fields = (
- assigned_to => 'Bugzilla::User',
- qa_contact => 'Bugzilla::User',
- reporter => 'Bugzilla::User',
- product => 'Bugzilla::Product',
- component => 'Bugzilla::Component',
- );
- my %translated;
-
- foreach my $field (keys %translate_fields) {
- my @ids;
- # Convert names to ids. We use "exists" everywhere since people can
- # legally specify "undef" to mean IS NULL (even though most of these
- # fields can't be NULL, people can still specify it...).
- if (exists $params->{$field}) {
- my $names = $params->{$field};
- my $type = $translate_fields{$field};
- my $param = $type eq 'Bugzilla::User' ? 'login_name' : 'name';
- # We call Bugzilla::Object::match directly to avoid the
- # Bugzilla::User::match implementation which is different.
- my $objects = Bugzilla::Object::match($type, { $param => $names });
- push(@ids, map { $_->id } @$objects);
- }
- # You can also specify ids directly as arguments to this function,
- # so include them in the list if they have been specified.
- if (exists $params->{"${field}_id"}) {
- my $current_ids = $params->{"${field}_id"};
- my @id_array = ref $current_ids ? @$current_ids : ($current_ids);
- push(@ids, @id_array);
- }
- # We do this "or" instead of a "scalar(@ids)" to handle the case
- # when people passed only invalid object names. Otherwise we'd
- # end up with a SUPER::match call with zero criteria (which dies).
- if (exists $params->{$field} or exists $params->{"${field}_id"}) {
- $translated{$field} = scalar(@ids) == 1 ? $ids[0] : \@ids;
- }
+ # The error the user sees depends on whether or not they are
+ # logged in (i.e. $user->id contains the user's positive integer ID).
+ # If we are validating an alias, then use it in the error message
+ # instead of its corresponding bug ID, to not disclose it.
+ if ($user->id) {
+ ThrowUserError("bug_access_denied", {bug_id => $input_id});
}
-
- # The user fields don't have an _id on the end of them in the database,
- # but the product & component fields do, so we have to have separate
- # code to deal with the different sets of fields here.
- foreach my $field (qw(assigned_to qa_contact reporter)) {
- delete $params->{"${field}_id"};
- $params->{$field} = $translated{$field}
- if exists $translated{$field};
- }
- foreach my $field (qw(product component)) {
- delete $params->{$field};
- $params->{"${field}_id"} = $translated{$field}
- if exists $translated{$field};
+ else {
+ ThrowUserError("bug_access_query", {bug_id => $input_id});
}
+ }
+}
- return $class->SUPER::match(@_);
+sub match {
+ my $class = shift;
+ my ($params) = @_;
+
+ # Allow matching certain fields by name (in addition to matching by ID).
+ my %translate_fields = (
+ assigned_to => 'Bugzilla::User',
+ qa_contact => 'Bugzilla::User',
+ reporter => 'Bugzilla::User',
+ product => 'Bugzilla::Product',
+ component => 'Bugzilla::Component',
+ );
+ my %translated;
+
+ foreach my $field (keys %translate_fields) {
+ my @ids;
+
+ # Convert names to ids. We use "exists" everywhere since people can
+ # legally specify "undef" to mean IS NULL (even though most of these
+ # fields can't be NULL, people can still specify it...).
+ if (exists $params->{$field}) {
+ my $names = $params->{$field};
+ my $type = $translate_fields{$field};
+ my $param = $type eq 'Bugzilla::User' ? 'login_name' : 'name';
+
+ # We call Bugzilla::Object::match directly to avoid the
+ # Bugzilla::User::match implementation which is different.
+ my $objects = Bugzilla::Object::match($type, {$param => $names});
+ push(@ids, map { $_->id } @$objects);
+ }
+
+ # You can also specify ids directly as arguments to this function,
+ # so include them in the list if they have been specified.
+ if (exists $params->{"${field}_id"}) {
+ my $current_ids = $params->{"${field}_id"};
+ my @id_array = ref $current_ids ? @$current_ids : ($current_ids);
+ push(@ids, @id_array);
+ }
+
+ # We do this "or" instead of a "scalar(@ids)" to handle the case
+ # when people passed only invalid object names. Otherwise we'd
+ # end up with a SUPER::match call with zero criteria (which dies).
+ if (exists $params->{$field} or exists $params->{"${field}_id"}) {
+ $translated{$field} = scalar(@ids) == 1 ? $ids[0] : \@ids;
+ }
+ }
+
+ # The user fields don't have an _id on the end of them in the database,
+ # but the product & component fields do, so we have to have separate
+ # code to deal with the different sets of fields here.
+ foreach my $field (qw(assigned_to qa_contact reporter)) {
+ delete $params->{"${field}_id"};
+ $params->{$field} = $translated{$field} if exists $translated{$field};
+ }
+ foreach my $field (qw(product component)) {
+ delete $params->{$field};
+ $params->{"${field}_id"} = $translated{$field} if exists $translated{$field};
+ }
+
+ return $class->SUPER::match(@_);
}
# Helps load up information for bugs for show_bug.cgi and other situations
# that will need to access info on lots of bugs.
sub preload {
- my ($class, $bugs) = @_;
- my $user = Bugzilla->user;
-
- # It would be faster but MUCH more complicated to select all the
- # deps for the entire list in one SQL statement. If we ever have
- # a profile that proves that that's necessary, we can switch over
- # to the more complex method.
- my @all_dep_ids;
- foreach my $bug (@$bugs) {
- push @all_dep_ids, @{ $bug->blocked }, @{ $bug->dependson };
- push @all_dep_ids, @{ $bug->duplicate_ids };
- push @all_dep_ids, @{ $bug->_preload_referenced_bugs };
- }
- @all_dep_ids = uniq @all_dep_ids;
- # If we don't do this, can_see_bug will do one call per bug in
- # the dependency and duplicate lists, in Bugzilla::Template::get_bug_link.
- $user->visible_bugs(\@all_dep_ids);
+ my ($class, $bugs) = @_;
+ my $user = Bugzilla->user;
+
+ # It would be faster but MUCH more complicated to select all the
+ # deps for the entire list in one SQL statement. If we ever have
+ # a profile that proves that that's necessary, we can switch over
+ # to the more complex method.
+ my @all_dep_ids;
+ foreach my $bug (@$bugs) {
+ push @all_dep_ids, @{$bug->blocked}, @{$bug->dependson};
+ push @all_dep_ids, @{$bug->duplicate_ids};
+ push @all_dep_ids, @{$bug->_preload_referenced_bugs};
+ }
+ @all_dep_ids = uniq @all_dep_ids;
+
+ # If we don't do this, can_see_bug will do one call per bug in
+ # the dependency and duplicate lists, in Bugzilla::Template::get_bug_link.
+ $user->visible_bugs(\@all_dep_ids);
}
# Helps load up bugs referenced in comments by retrieving them with a single
# query from the database and injecting bug objects into the object-cache.
sub _preload_referenced_bugs {
- my $self = shift;
+ my $self = shift;
- # inject current duplicates into the object-cache first
- foreach my $bug (@{ $self->duplicates }) {
- $bug->object_cache_set() unless Bugzilla::Bug->object_cache_get($bug->id);
- }
+ # inject current duplicates into the object-cache first
+ foreach my $bug (@{$self->duplicates}) {
+ $bug->object_cache_set() unless Bugzilla::Bug->object_cache_get($bug->id);
+ }
- # preload bugs from comments
- my $referenced_bug_ids = _extract_bug_ids($self->comments);
- my @ref_bug_ids = grep { !Bugzilla::Bug->object_cache_get($_) } @$referenced_bug_ids;
+ # preload bugs from comments
+ my $referenced_bug_ids = _extract_bug_ids($self->comments);
+ my @ref_bug_ids
+ = grep { !Bugzilla::Bug->object_cache_get($_) } @$referenced_bug_ids;
- # inject into object-cache
- my $referenced_bugs = Bugzilla::Bug->new_from_list(\@ref_bug_ids);
- $_->object_cache_set() foreach @$referenced_bugs;
+ # inject into object-cache
+ my $referenced_bugs = Bugzilla::Bug->new_from_list(\@ref_bug_ids);
+ $_->object_cache_set() foreach @$referenced_bugs;
- return $referenced_bug_ids;
+ return $referenced_bug_ids;
}
# Extract bug IDs mentioned in comments. This is much faster than calling quoteUrls().
sub _extract_bug_ids {
- my $comments = shift;
- my @bug_ids;
-
- my $params = Bugzilla->params;
- my @urlbases = ($params->{'urlbase'});
- push(@urlbases, $params->{'sslbase'}) if $params->{'sslbase'};
- my $urlbase_re = '(?:' . join('|', map { qr/$_/ } @urlbases) . ')';
- my $bug_word = template_var('terms')->{bug};
- my $bugs_word = template_var('terms')->{bugs};
-
- foreach my $comment (@$comments) {
- if ($comment->type == CMT_HAS_DUPE || $comment->type == CMT_DUPE_OF) {
- push @bug_ids, $comment->extra_data;
- next;
- }
- my $s = $comment->already_wrapped ? qr/\s/ : qr/\h/;
- my $text = $comment->body;
- # Full bug links
- push @bug_ids, $text =~ /\b$urlbase_re\Qshow_bug.cgi?id=\E([0-9]+)(?:\#c[0-9]+)?/g;
- # bug X
- my $bug_re = qr/\Q$bug_word\E$s*\#?$s*([0-9]+)/i;
- push @bug_ids, $text =~ /\b$bug_re/g;
- # bugs X, Y, Z
- my $bugs_re = qr/\Q$bugs_word\E$s*\#?$s*([0-9]+)(?:$s*,$s*\#?$s*([0-9]+))+/i;
- push @bug_ids, $text =~ /\b$bugs_re/g;
- # Old duplicate markers
- push @bug_ids, $text =~ /(?<=^\*\*\*\ This\ bug\ has\ been\ marked\ as\ a\ duplicate\ of\ )([0-9]+)(?=\ \*\*\*\Z)/;
- }
- # Make sure to filter invalid bug IDs.
- @bug_ids = grep { $_ < MAX_INT_32 } @bug_ids;
- return [uniq @bug_ids];
-}
+ my $comments = shift;
+ my @bug_ids;
-sub possible_duplicates {
- my ($class, $params) = @_;
- my $short_desc = $params->{summary};
- my $products = $params->{products} || [];
- my $limit = $params->{limit} || MAX_POSSIBLE_DUPLICATES;
- $limit = MAX_POSSIBLE_DUPLICATES if $limit > MAX_POSSIBLE_DUPLICATES;
- $products = [$products] if !ref($products) eq 'ARRAY';
-
- my $orig_limit = $limit;
- detaint_natural($limit)
- || ThrowCodeError('param_must_be_numeric',
- { function => 'possible_duplicates',
- param => $orig_limit });
+ my $params = Bugzilla->params;
+ my @urlbases = ($params->{'urlbase'});
+ push(@urlbases, $params->{'sslbase'}) if $params->{'sslbase'};
+ my $urlbase_re = '(?:' . join('|', map {qr/$_/} @urlbases) . ')';
+ my $bug_word = template_var('terms')->{bug};
+ my $bugs_word = template_var('terms')->{bugs};
- my $dbh = Bugzilla->dbh;
- my $user = Bugzilla->user;
- my @words = split(/[\b\s]+/, $short_desc || '');
- # Remove leading/trailing punctuation from words
- foreach my $word (@words) {
- $word =~ s/(?:^\W+|\W+$)//g;
+ foreach my $comment (@$comments) {
+ if ($comment->type == CMT_HAS_DUPE || $comment->type == CMT_DUPE_OF) {
+ push @bug_ids, $comment->extra_data;
+ next;
}
- # And make sure that each word is longer than 2 characters.
- @words = grep { defined $_ and length($_) > 2 } @words;
+ my $s = $comment->already_wrapped ? qr/\s/ : qr/\h/;
+ my $text = $comment->body;
- return [] if !@words;
+ # Full bug links
+ push @bug_ids,
+ $text =~ /\b$urlbase_re\Qshow_bug.cgi?id=\E([0-9]+)(?:\#c[0-9]+)?/g;
- my ($where_sql, $relevance_sql);
- if ($dbh->FULLTEXT_OR) {
- my $joined_terms = join($dbh->FULLTEXT_OR, @words);
- ($where_sql, $relevance_sql) =
- $dbh->sql_fulltext_search('bugs_fulltext.short_desc', $joined_terms);
- $relevance_sql ||= $where_sql;
- }
- else {
- my (@where, @relevance);
- foreach my $word (@words) {
- my ($term, $rel_term) = $dbh->sql_fulltext_search(
- 'bugs_fulltext.short_desc', $word);
- push(@where, $term);
- push(@relevance, $rel_term || $term);
- }
+ # bug X
+ my $bug_re = qr/\Q$bug_word\E$s*\#?$s*([0-9]+)/i;
+ push @bug_ids, $text =~ /\b$bug_re/g;
+
+ # bugs X, Y, Z
+ my $bugs_re = qr/\Q$bugs_word\E$s*\#?$s*([0-9]+)(?:$s*,$s*\#?$s*([0-9]+))+/i;
+ push @bug_ids, $text =~ /\b$bugs_re/g;
+
+ # Old duplicate markers
+ push @bug_ids, $text
+ =~ /(?<=^\*\*\*\ This\ bug\ has\ been\ marked\ as\ a\ duplicate\ of\ )([0-9]+)(?=\ \*\*\*\Z)/;
+ }
+
+ # Make sure to filter invalid bug IDs.
+ @bug_ids = grep { $_ < MAX_INT_32 } @bug_ids;
+ return [uniq @bug_ids];
+}
- $where_sql = join(' OR ', @where);
- $relevance_sql = join(' + ', @relevance);
+sub possible_duplicates {
+ my ($class, $params) = @_;
+ my $short_desc = $params->{summary};
+ my $products = $params->{products} || [];
+ my $limit = $params->{limit} || MAX_POSSIBLE_DUPLICATES;
+ $limit = MAX_POSSIBLE_DUPLICATES if $limit > MAX_POSSIBLE_DUPLICATES;
+ $products = [$products] if !ref($products) eq 'ARRAY';
+
+ my $orig_limit = $limit;
+ detaint_natural($limit)
+ || ThrowCodeError('param_must_be_numeric',
+ {function => 'possible_duplicates', param => $orig_limit});
+
+ my $dbh = Bugzilla->dbh;
+ my $user = Bugzilla->user;
+ my @words = split(/[\b\s]+/, $short_desc || '');
+
+ # Remove leading/trailing punctuation from words
+ foreach my $word (@words) {
+ $word =~ s/(?:^\W+|\W+$)//g;
+ }
+
+ # And make sure that each word is longer than 2 characters.
+ @words = grep { defined $_ and length($_) > 2 } @words;
+
+ return [] if !@words;
+
+ my ($where_sql, $relevance_sql);
+ if ($dbh->FULLTEXT_OR) {
+ my $joined_terms = join($dbh->FULLTEXT_OR, @words);
+ ($where_sql, $relevance_sql)
+ = $dbh->sql_fulltext_search('bugs_fulltext.short_desc', $joined_terms);
+ $relevance_sql ||= $where_sql;
+ }
+ else {
+ my (@where, @relevance);
+ foreach my $word (@words) {
+ my ($term, $rel_term)
+ = $dbh->sql_fulltext_search('bugs_fulltext.short_desc', $word);
+ push(@where, $term);
+ push(@relevance, $rel_term || $term);
}
- my $product_ids = join(',', map { $_->id } @$products);
- my $product_sql = $product_ids ? "AND product_id IN ($product_ids)" : "";
+ $where_sql = join(' OR ', @where);
+ $relevance_sql = join(' + ', @relevance);
+ }
+
+ my $product_ids = join(',', map { $_->id } @$products);
+ my $product_sql = $product_ids ? "AND product_id IN ($product_ids)" : "";
- # Because we collapse duplicates, we want to get slightly more bugs
- # than were actually asked for.
- my $sql_limit = $limit + 5;
+ # Because we collapse duplicates, we want to get slightly more bugs
+ # than were actually asked for.
+ my $sql_limit = $limit + 5;
- my $possible_dupes = $dbh->selectall_arrayref(
- "SELECT bugs.bug_id AS bug_id, bugs.resolution AS resolution,
+ my $possible_dupes = $dbh->selectall_arrayref(
+ "SELECT bugs.bug_id AS bug_id, bugs.resolution AS resolution,
($relevance_sql) AS relevance
FROM bugs
INNER JOIN bugs_fulltext ON bugs.bug_id = bugs_fulltext.bug_id
WHERE ($where_sql) $product_sql
- ORDER BY relevance DESC, bug_id DESC " .
- $dbh->sql_limit($sql_limit), {Slice=>{}});
-
- my @actual_dupe_ids;
- # Resolve duplicates into their ultimate target duplicates.
- foreach my $bug (@$possible_dupes) {
- my $push_id = $bug->{bug_id};
- if ($bug->{resolution} && $bug->{resolution} eq 'DUPLICATE') {
- $push_id = _resolve_ultimate_dup_id($bug->{bug_id});
- }
- push(@actual_dupe_ids, $push_id);
- }
- @actual_dupe_ids = uniq @actual_dupe_ids;
- if (scalar @actual_dupe_ids > $limit) {
- @actual_dupe_ids = @actual_dupe_ids[0..($limit-1)];
+ ORDER BY relevance DESC, bug_id DESC " . $dbh->sql_limit($sql_limit),
+ {Slice => {}}
+ );
+
+ my @actual_dupe_ids;
+
+ # Resolve duplicates into their ultimate target duplicates.
+ foreach my $bug (@$possible_dupes) {
+ my $push_id = $bug->{bug_id};
+ if ($bug->{resolution} && $bug->{resolution} eq 'DUPLICATE') {
+ $push_id = _resolve_ultimate_dup_id($bug->{bug_id});
}
+ push(@actual_dupe_ids, $push_id);
+ }
+ @actual_dupe_ids = uniq @actual_dupe_ids;
+ if (scalar @actual_dupe_ids > $limit) {
+ @actual_dupe_ids = @actual_dupe_ids[0 .. ($limit - 1)];
+ }
- my $visible = $user->visible_bugs(\@actual_dupe_ids);
- return $class->new_from_list($visible);
+ my $visible = $user->visible_bugs(\@actual_dupe_ids);
+ return $class->new_from_list($visible);
}
# Docs for create() (there's no POD in this file yet, but we very
@@ -680,591 +693,614 @@ sub possible_duplicates {
#
# C<assigned_to> - The full login name of the user who the bug is
# initially assigned to.
-# C<qa_contact> - The full login name of the QA Contact for this bug.
+# C<qa_contact> - The full login name of the QA Contact for this bug.
# Will be ignored if C<useqacontact> is off.
#
-# C<estimated_time> - For time-tracking. Will be ignored if
+# C<estimated_time> - For time-tracking. Will be ignored if
# C<timetrackinggroup> is not set, or if the current
# user is not a member of the timetrackinggroup.
# C<deadline> - For time-tracking. Will be ignored for the same
# reasons as C<estimated_time>.
sub create {
- my ($class, $params) = @_;
- my $dbh = Bugzilla->dbh;
-
- $dbh->bz_start_transaction();
-
- # These fields have default values which we can use if they are undefined.
- $params->{bug_severity} = Bugzilla->params->{defaultseverity}
- unless defined $params->{bug_severity};
- $params->{priority} = Bugzilla->params->{defaultpriority}
- unless defined $params->{priority};
- $params->{op_sys} = Bugzilla->params->{defaultopsys}
- unless defined $params->{op_sys};
- $params->{rep_platform} = Bugzilla->params->{defaultplatform}
- unless defined $params->{rep_platform};
- # Make sure a comment is always defined.
- $params->{comment} = '' unless defined $params->{comment};
-
- $class->check_required_create_fields($params);
- $params = $class->run_create_validators($params);
-
- # These are not a fields in the bugs table, so we don't pass them to
- # insert_create_data.
- my $bug_aliases = delete $params->{alias};
- my $cc_ids = delete $params->{cc};
- my $groups = delete $params->{groups};
- my $depends_on = delete $params->{dependson};
- my $blocked = delete $params->{blocked};
- my $keywords = delete $params->{keywords};
- my $creation_comment = delete $params->{comment};
- my $see_also = delete $params->{see_also};
-
- # We don't want the bug to appear in the system until it's correctly
- # protected by groups.
- my $timestamp = delete $params->{creation_ts};
-
- my $ms_values = $class->_extract_multi_selects($params);
- my $bug = $class->insert_create_data($params);
-
- # Add the group restrictions
- my $sth_group = $dbh->prepare(
- 'INSERT INTO bug_group_map (bug_id, group_id) VALUES (?, ?)');
- foreach my $group (@$groups) {
- $sth_group->execute($bug->bug_id, $group->id);
- }
-
- $dbh->do('UPDATE bugs SET creation_ts = ? WHERE bug_id = ?', undef,
- $timestamp, $bug->bug_id);
- # Update the bug instance as well
- $bug->{creation_ts} = $timestamp;
-
- # Add the CCs
- my $sth_cc = $dbh->prepare('INSERT INTO cc (bug_id, who) VALUES (?,?)');
- foreach my $user_id (@$cc_ids) {
- $sth_cc->execute($bug->bug_id, $user_id);
- }
-
- # Add in keywords
- my $sth_keyword = $dbh->prepare(
- 'INSERT INTO keywords (bug_id, keywordid) VALUES (?, ?)');
- foreach my $keyword_id (map($_->id, @$keywords)) {
- $sth_keyword->execute($bug->bug_id, $keyword_id);
- }
-
- # Set up dependencies (blocked/dependson)
- my $sth_deps = $dbh->prepare(
- 'INSERT INTO dependencies (blocked, dependson) VALUES (?, ?)');
- my $sth_bug_time = $dbh->prepare('UPDATE bugs SET delta_ts = ? WHERE bug_id = ?');
-
- foreach my $depends_on_id (@$depends_on) {
- $sth_deps->execute($bug->bug_id, $depends_on_id);
- # Log the reverse action on the other bug.
- LogActivityEntry($depends_on_id, 'blocked', '', $bug->bug_id,
- $bug->{reporter_id}, $timestamp);
- $sth_bug_time->execute($timestamp, $depends_on_id);
- }
- foreach my $blocked_id (@$blocked) {
- $sth_deps->execute($blocked_id, $bug->bug_id);
- # Log the reverse action on the other bug.
- LogActivityEntry($blocked_id, 'dependson', '', $bug->bug_id,
- $bug->{reporter_id}, $timestamp);
- $sth_bug_time->execute($timestamp, $blocked_id);
- }
-
- # Insert the values into the multiselect value tables
- foreach my $field (keys %$ms_values) {
- $dbh->do("DELETE FROM bug_$field where bug_id = ?",
- undef, $bug->bug_id);
- foreach my $value ( @{$ms_values->{$field}} ) {
- $dbh->do("INSERT INTO bug_$field (bug_id, value) VALUES (?,?)",
- undef, $bug->bug_id, $value);
- }
- }
-
- # Insert any see_also values
- if ($see_also) {
- my $see_also_array = $see_also;
- if (!ref $see_also_array) {
- $see_also = trim($see_also);
- $see_also_array = [ split(/[\s,]+/, $see_also) ];
- }
- foreach my $value (@$see_also_array) {
- $bug->add_see_also($value);
- }
- foreach my $see_also (@{ $bug->see_also }) {
- $see_also->insert_create_data($see_also);
- }
- foreach my $ref_bug (@{ $bug->{_update_ref_bugs} || [] }) {
- $ref_bug->update();
- }
- delete $bug->{_update_ref_bugs};
- }
-
- # Comment #0 handling...
-
- # We now have a bug id so we can fill this out
- $creation_comment->{'bug_id'} = $bug->id;
-
- # Insert the comment. We always insert a comment on bug creation,
- # but sometimes it's blank.
- Bugzilla::Comment->insert_create_data($creation_comment);
-
- # Set up aliases
- my $sth_aliases = $dbh->prepare('INSERT INTO bugs_aliases (alias, bug_id) VALUES (?, ?)');
- foreach my $alias (@$bug_aliases) {
- trick_taint($alias);
- $sth_aliases->execute($alias, $bug->bug_id);
- }
+ my ($class, $params) = @_;
+ my $dbh = Bugzilla->dbh;
+
+ $dbh->bz_start_transaction();
+
+ # These fields have default values which we can use if they are undefined.
+ $params->{bug_severity} = Bugzilla->params->{defaultseverity}
+ unless defined $params->{bug_severity};
+ $params->{priority} = Bugzilla->params->{defaultpriority}
+ unless defined $params->{priority};
+ $params->{op_sys} = Bugzilla->params->{defaultopsys}
+ unless defined $params->{op_sys};
+ $params->{rep_platform} = Bugzilla->params->{defaultplatform}
+ unless defined $params->{rep_platform};
+
+ # Make sure a comment is always defined.
+ $params->{comment} = '' unless defined $params->{comment};
+
+ $class->check_required_create_fields($params);
+ $params = $class->run_create_validators($params);
+
+ # These are not a fields in the bugs table, so we don't pass them to
+ # insert_create_data.
+ my $bug_aliases = delete $params->{alias};
+ my $cc_ids = delete $params->{cc};
+ my $groups = delete $params->{groups};
+ my $depends_on = delete $params->{dependson};
+ my $blocked = delete $params->{blocked};
+ my $keywords = delete $params->{keywords};
+ my $creation_comment = delete $params->{comment};
+ my $see_also = delete $params->{see_also};
+
+ # We don't want the bug to appear in the system until it's correctly
+ # protected by groups.
+ my $timestamp = delete $params->{creation_ts};
+
+ my $ms_values = $class->_extract_multi_selects($params);
+ my $bug = $class->insert_create_data($params);
+
+ # Add the group restrictions
+ my $sth_group
+ = $dbh->prepare('INSERT INTO bug_group_map (bug_id, group_id) VALUES (?, ?)');
+ foreach my $group (@$groups) {
+ $sth_group->execute($bug->bug_id, $group->id);
+ }
+
+ $dbh->do('UPDATE bugs SET creation_ts = ? WHERE bug_id = ?',
+ undef, $timestamp, $bug->bug_id);
+
+ # Update the bug instance as well
+ $bug->{creation_ts} = $timestamp;
+
+ # Add the CCs
+ my $sth_cc = $dbh->prepare('INSERT INTO cc (bug_id, who) VALUES (?,?)');
+ foreach my $user_id (@$cc_ids) {
+ $sth_cc->execute($bug->bug_id, $user_id);
+ }
+
+ # Add in keywords
+ my $sth_keyword
+ = $dbh->prepare('INSERT INTO keywords (bug_id, keywordid) VALUES (?, ?)');
+ foreach my $keyword_id (map($_->id, @$keywords)) {
+ $sth_keyword->execute($bug->bug_id, $keyword_id);
+ }
+
+ # Set up dependencies (blocked/dependson)
+ my $sth_deps = $dbh->prepare(
+ 'INSERT INTO dependencies (blocked, dependson) VALUES (?, ?)');
+ my $sth_bug_time
+ = $dbh->prepare('UPDATE bugs SET delta_ts = ? WHERE bug_id = ?');
+
+ foreach my $depends_on_id (@$depends_on) {
+ $sth_deps->execute($bug->bug_id, $depends_on_id);
+
+ # Log the reverse action on the other bug.
+ LogActivityEntry($depends_on_id, 'blocked', '', $bug->bug_id,
+ $bug->{reporter_id}, $timestamp);
+ $sth_bug_time->execute($timestamp, $depends_on_id);
+ }
+ foreach my $blocked_id (@$blocked) {
+ $sth_deps->execute($blocked_id, $bug->bug_id);
+
+ # Log the reverse action on the other bug.
+ LogActivityEntry($blocked_id, 'dependson', '', $bug->bug_id,
+ $bug->{reporter_id}, $timestamp);
+ $sth_bug_time->execute($timestamp, $blocked_id);
+ }
+
+ # Insert the values into the multiselect value tables
+ foreach my $field (keys %$ms_values) {
+ $dbh->do("DELETE FROM bug_$field where bug_id = ?", undef, $bug->bug_id);
+ foreach my $value (@{$ms_values->{$field}}) {
+ $dbh->do("INSERT INTO bug_$field (bug_id, value) VALUES (?,?)",
+ undef, $bug->bug_id, $value);
+ }
+ }
+
+ # Insert any see_also values
+ if ($see_also) {
+ my $see_also_array = $see_also;
+ if (!ref $see_also_array) {
+ $see_also = trim($see_also);
+ $see_also_array = [split(/[\s,]+/, $see_also)];
+ }
+ foreach my $value (@$see_also_array) {
+ $bug->add_see_also($value);
+ }
+ foreach my $see_also (@{$bug->see_also}) {
+ $see_also->insert_create_data($see_also);
+ }
+ foreach my $ref_bug (@{$bug->{_update_ref_bugs} || []}) {
+ $ref_bug->update();
+ }
+ delete $bug->{_update_ref_bugs};
+ }
+
+ # Comment #0 handling...
+
+ # We now have a bug id so we can fill this out
+ $creation_comment->{'bug_id'} = $bug->id;
+
+ # Insert the comment. We always insert a comment on bug creation,
+ # but sometimes it's blank.
+ Bugzilla::Comment->insert_create_data($creation_comment);
+
+ # Set up aliases
+ my $sth_aliases
+ = $dbh->prepare('INSERT INTO bugs_aliases (alias, bug_id) VALUES (?, ?)');
+ foreach my $alias (@$bug_aliases) {
+ trick_taint($alias);
+ $sth_aliases->execute($alias, $bug->bug_id);
+ }
- Bugzilla::Hook::process('bug_end_of_create', { bug => $bug,
- timestamp => $timestamp,
- });
+ Bugzilla::Hook::process('bug_end_of_create',
+ {bug => $bug, timestamp => $timestamp,});
- $dbh->bz_commit_transaction();
+ $bug->_sync_fulltext(new_bug => 1);
- # Because MySQL doesn't support transactions on the fulltext table,
- # we do this after we've committed the transaction. That way we're
- # sure we're inserting a good Bug ID.
- $bug->_sync_fulltext( new_bug => 1 );
+ $dbh->bz_commit_transaction();
- return $bug;
+ return $bug;
}
sub run_create_validators {
- my $class = shift;
- my $params = $class->SUPER::run_create_validators(@_);
-
- # Add classification for checking mandatory fields which depend on it
- $params->{classification} = $params->{product}->classification->name;
-
- my @mandatory_fields = @{ Bugzilla->fields({ is_mandatory => 1,
- enter_bug => 1,
- obsolete => 0 }) };
- foreach my $field (@mandatory_fields) {
- $class->_check_field_is_mandatory($params->{$field->name}, $field,
- $params);
- }
-
- my $product = delete $params->{product};
- $params->{product_id} = $product->id;
- my $component = delete $params->{component};
- $params->{component_id} = $component->id;
-
- # Callers cannot set reporter, creation_ts, or delta_ts.
- $params->{reporter} = $class->_check_reporter();
- $params->{delta_ts} = $params->{creation_ts};
-
- if ($params->{estimated_time}) {
- $params->{remaining_time} = $params->{estimated_time};
- }
-
- $class->_check_strict_isolation($params->{cc}, $params->{assigned_to},
- $params->{qa_contact}, $product);
+ my $class = shift;
+ my $params = $class->SUPER::run_create_validators(@_);
- # You can't set these fields.
- delete $params->{lastdiffed};
- delete $params->{bug_id};
- delete $params->{classification};
+ # Add classification for checking mandatory fields which depend on it
+ $params->{classification} = $params->{product}->classification->name;
- Bugzilla::Hook::process('bug_end_of_create_validators',
- { params => $params });
+ my @mandatory_fields
+ = @{Bugzilla->fields({is_mandatory => 1, enter_bug => 1, obsolete => 0})};
+ foreach my $field (@mandatory_fields) {
+ $class->_check_field_is_mandatory($params->{$field->name}, $field, $params);
+ }
- # And this is not a valid DB field, it's just used as part of
- # _check_dependencies to avoid running it twice for both blocked
- # and dependson.
- delete $params->{_dependencies_validated};
+ my $product = delete $params->{product};
+ $params->{product_id} = $product->id;
+ my $component = delete $params->{component};
+ $params->{component_id} = $component->id;
- return $params;
-}
+ # Callers cannot set reporter, creation_ts, or delta_ts.
+ $params->{reporter} = $class->_check_reporter();
+ $params->{delta_ts} = $params->{creation_ts};
-sub update {
- my $self = shift;
- my $dbh = Bugzilla->dbh;
- my $user = Bugzilla->user;
+ if ($params->{estimated_time}) {
+ $params->{remaining_time} = $params->{estimated_time};
+ }
- # XXX This is just a temporary hack until all updating happens
- # inside this function.
- my $delta_ts = shift || $dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)');
+ $class->_check_strict_isolation($params->{cc}, $params->{assigned_to},
+ $params->{qa_contact}, $product);
- $dbh->bz_start_transaction();
+ # You can't set these fields.
+ delete $params->{lastdiffed};
+ delete $params->{bug_id};
+ delete $params->{classification};
- my ($changes, $old_bug) = $self->SUPER::update(@_);
+ Bugzilla::Hook::process('bug_end_of_create_validators', {params => $params});
- Bugzilla::Hook::process('bug_start_of_update',
- { timestamp => $delta_ts, bug => $self,
- old_bug => $old_bug, changes => $changes });
+ # And this is not a valid DB field, it's just used as part of
+ # _check_dependencies to avoid running it twice for both blocked
+ # and dependson.
+ delete $params->{_dependencies_validated};
- # Certain items in $changes have to be fixed so that they hold
- # a name instead of an ID.
- foreach my $field (qw(product_id component_id)) {
- my $change = delete $changes->{$field};
- if ($change) {
- my $new_field = $field;
- $new_field =~ s/_id$//;
- $changes->{$new_field} =
- [$self->{"_old_${new_field}_name"}, $self->$new_field];
- }
- }
- foreach my $field (qw(qa_contact assigned_to)) {
- if ($changes->{$field}) {
- my ($from, $to) = @{ $changes->{$field} };
- $from = $old_bug->$field->login if $from;
- $to = $self->$field->login if $to;
- $changes->{$field} = [$from, $to];
- }
- }
-
- # CC
- my @old_cc = map {$_->id} @{$old_bug->cc_users};
- my @new_cc = map {$_->id} @{$self->cc_users};
- my ($removed_cc, $added_cc) = diff_arrays(\@old_cc, \@new_cc);
-
- if (scalar @$removed_cc) {
- $dbh->do('DELETE FROM cc WHERE bug_id = ? AND '
- . $dbh->sql_in('who', $removed_cc), undef, $self->id);
- }
- foreach my $user_id (@$added_cc) {
- $dbh->do('INSERT INTO cc (bug_id, who) VALUES (?,?)',
- undef, $self->id, $user_id);
- }
- # If any changes were found, record it in the activity log
- if (scalar @$removed_cc || scalar @$added_cc) {
- my $removed_users = Bugzilla::User->new_from_list($removed_cc);
- my $added_users = Bugzilla::User->new_from_list($added_cc);
- my $removed_names = join(', ', (map {$_->login} @$removed_users));
- my $added_names = join(', ', (map {$_->login} @$added_users));
- $changes->{cc} = [$removed_names, $added_names];
- }
-
- # Aliases
- my $old_aliases = $old_bug->alias;
- my $new_aliases = $self->alias;
- my ($removed_aliases, $added_aliases) = diff_arrays($old_aliases, $new_aliases);
-
- foreach my $alias (@$removed_aliases) {
- $dbh->do('DELETE FROM bugs_aliases WHERE bug_id = ? AND alias = ?',
- undef, $self->id, $alias);
- }
- foreach my $alias (@$added_aliases) {
- trick_taint($alias);
- $dbh->do('INSERT INTO bugs_aliases (bug_id, alias) VALUES (?,?)',
- undef, $self->id, $alias);
- }
- # If any changes were found, record it in the activity log
- if (scalar @$removed_aliases || scalar @$added_aliases) {
- $changes->{alias} = [join(', ', @$removed_aliases), join(', ', @$added_aliases)];
- }
-
- # Keywords
- my @old_kw_ids = map { $_->id } @{$old_bug->keyword_objects};
- my @new_kw_ids = map { $_->id } @{$self->keyword_objects};
-
- my ($removed_kw, $added_kw) = diff_arrays(\@old_kw_ids, \@new_kw_ids);
-
- if (scalar @$removed_kw) {
- $dbh->do('DELETE FROM keywords WHERE bug_id = ? AND '
- . $dbh->sql_in('keywordid', $removed_kw), undef, $self->id);
- }
- foreach my $keyword_id (@$added_kw) {
- $dbh->do('INSERT INTO keywords (bug_id, keywordid) VALUES (?,?)',
- undef, $self->id, $keyword_id);
- }
- # If any changes were found, record it in the activity log
- if (scalar @$removed_kw || scalar @$added_kw) {
- my $removed_keywords = Bugzilla::Keyword->new_from_list($removed_kw);
- my $added_keywords = Bugzilla::Keyword->new_from_list($added_kw);
- my $removed_names = join(', ', (map {$_->name} @$removed_keywords));
- my $added_names = join(', ', (map {$_->name} @$added_keywords));
- $changes->{keywords} = [$removed_names, $added_names];
- }
-
- # Dependencies
- foreach my $pair ([qw(dependson blocked)], [qw(blocked dependson)]) {
- my ($type, $other) = @$pair;
- my $old = $old_bug->$type;
- my $new = $self->$type;
-
- my ($removed, $added) = diff_arrays($old, $new);
- foreach my $removed_id (@$removed) {
- $dbh->do("DELETE FROM dependencies WHERE $type = ? AND $other = ?",
- undef, $removed_id, $self->id);
-
- # Add an activity entry for the other bug.
- LogActivityEntry($removed_id, $other, $self->id, '',
- $user->id, $delta_ts);
- # Update delta_ts on the other bug so that we trigger mid-airs.
- $dbh->do('UPDATE bugs SET delta_ts = ? WHERE bug_id = ?',
- undef, $delta_ts, $removed_id);
- }
- foreach my $added_id (@$added) {
- $dbh->do("INSERT INTO dependencies ($type, $other) VALUES (?,?)",
- undef, $added_id, $self->id);
-
- # Add an activity entry for the other bug.
- LogActivityEntry($added_id, $other, '', $self->id,
- $user->id, $delta_ts);
- # Update delta_ts on the other bug so that we trigger mid-airs.
- $dbh->do('UPDATE bugs SET delta_ts = ? WHERE bug_id = ?',
- undef, $delta_ts, $added_id);
- }
-
- if (scalar(@$removed) || scalar(@$added)) {
- $changes->{$type} = [join(', ', @$removed), join(', ', @$added)];
- }
- }
-
- # Groups
- my %old_groups = map {$_->id => $_} @{$old_bug->groups_in};
- my %new_groups = map {$_->id => $_} @{$self->groups_in};
- my ($removed_gr, $added_gr) = diff_arrays([keys %old_groups],
- [keys %new_groups]);
- if (scalar @$removed_gr || scalar @$added_gr) {
- if (@$removed_gr) {
- my $qmarks = join(',', ('?') x @$removed_gr);
- $dbh->do("DELETE FROM bug_group_map
- WHERE bug_id = ? AND group_id IN ($qmarks)", undef,
- $self->id, @$removed_gr);
- }
- my $sth_insert = $dbh->prepare(
- 'INSERT INTO bug_group_map (bug_id, group_id) VALUES (?,?)');
- foreach my $gid (@$added_gr) {
- $sth_insert->execute($self->id, $gid);
- }
- my @removed_names = map { $old_groups{$_}->name } @$removed_gr;
- my @added_names = map { $new_groups{$_}->name } @$added_gr;
- $changes->{'bug_group'} = [join(', ', @removed_names),
- join(', ', @added_names)];
- }
-
- # Comments
- foreach my $comment (@{$self->{added_comments} || []}) {
- # Override the Comment's timestamp to be identical to the update
- # timestamp.
- $comment->{bug_when} = $delta_ts;
- $comment = Bugzilla::Comment->insert_create_data($comment);
- if ($comment->work_time) {
- LogActivityEntry($self->id, "work_time", "", $comment->work_time,
- $user->id, $delta_ts);
- }
- }
-
- # Comment Privacy
- foreach my $comment (@{$self->{comment_isprivate} || []}) {
- $comment->update();
-
- my ($from, $to)
- = $comment->is_private ? (0, 1) : (1, 0);
- LogActivityEntry($self->id, "longdescs.isprivate", $from, $to,
- $user->id, $delta_ts, $comment->id);
- }
-
- # Clear the cache of comments
- delete $self->{comments};
-
- # Insert the values into the multiselect value tables
- my @multi_selects = grep {$_->type == FIELD_TYPE_MULTI_SELECT}
- Bugzilla->active_custom_fields;
- foreach my $field (@multi_selects) {
- my $name = $field->name;
- my ($removed, $added) = diff_arrays($old_bug->$name, $self->$name);
- if (scalar @$removed || scalar @$added) {
- $changes->{$name} = [join(', ', @$removed), join(', ', @$added)];
-
- $dbh->do("DELETE FROM bug_$name where bug_id = ?",
- undef, $self->id);
- foreach my $value (@{$self->$name}) {
- $dbh->do("INSERT INTO bug_$name (bug_id, value) VALUES (?,?)",
- undef, $self->id, $value);
- }
- }
- }
-
- # See Also
-
- my ($removed_see, $added_see) =
- diff_arrays($old_bug->see_also, $self->see_also, 'name');
-
- $_->remove_from_db foreach @$removed_see;
- $_->insert_create_data($_) foreach @$added_see;
-
- # If any changes were found, record it in the activity log
- if (scalar @$removed_see || scalar @$added_see) {
- $changes->{see_also} = [join(', ', map { $_->name } @$removed_see),
- join(', ', map { $_->name } @$added_see)];
- }
+ return $params;
+}
- # Flags
- my ($removed, $added) = Bugzilla::Flag->update_flags($self, $old_bug, $delta_ts);
- if ($removed || $added) {
- $changes->{'flagtypes.name'} = [$removed, $added];
- }
+sub update {
+ my $self = shift;
+ my $dbh = Bugzilla->dbh;
+ my $user = Bugzilla->user;
- $_->update foreach @{ $self->{_update_ref_bugs} || [] };
- delete $self->{_update_ref_bugs};
-
- # Log bugs_activity items
- # XXX Eventually, when bugs_activity is able to track the dupe_id,
- # this code should go below the duplicates-table-updating code below.
- foreach my $field (keys %$changes) {
- my $change = $changes->{$field};
- my $from = defined $change->[0] ? $change->[0] : '';
- my $to = defined $change->[1] ? $change->[1] : '';
- LogActivityEntry($self->id, $field, $from, $to,
- $user->id, $delta_ts);
- }
+ # XXX This is just a temporary hack until all updating happens
+ # inside this function.
+ my $delta_ts = shift || $dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)');
- # Check if we have to update the duplicates table and the other bug.
- my ($old_dup, $cur_dup) = ($old_bug->dup_id || 0, $self->dup_id || 0);
- if ($old_dup != $cur_dup) {
- $dbh->do("DELETE FROM duplicates WHERE dupe = ?", undef, $self->id);
- if ($cur_dup) {
- $dbh->do('INSERT INTO duplicates (dupe, dupe_of) VALUES (?,?)',
- undef, $self->id, $cur_dup);
- if (my $update_dup = delete $self->{_dup_for_update}) {
- $update_dup->update();
- }
- }
+ $dbh->bz_start_transaction();
- $changes->{'dup_id'} = [$old_dup || undef, $cur_dup || undef];
- }
+ my ($changes, $old_bug) = $self->SUPER::update(@_);
- Bugzilla::Hook::process('bug_end_of_update',
- { bug => $self, timestamp => $delta_ts, changes => $changes,
- old_bug => $old_bug });
-
- # If any change occurred, refresh the timestamp of the bug.
- if (scalar(keys %$changes) || $self->{added_comments}
- || $self->{comment_isprivate})
+ Bugzilla::Hook::process(
+ 'bug_start_of_update',
{
- $dbh->do('UPDATE bugs SET delta_ts = ? WHERE bug_id = ?',
- undef, ($delta_ts, $self->id));
- $self->{delta_ts} = $delta_ts;
- }
-
- # Update last-visited
- if ($user->is_involved_in_bug($self)) {
- $self->update_user_last_visit($user, $delta_ts);
- }
-
- # If a user is no longer involved, remove their last visit entry
- my $last_visits =
- Bugzilla::BugUserLastVisit->match({ bug_id => $self->id });
- foreach my $lv (@$last_visits) {
- $lv->remove_from_db() unless $lv->user->is_involved_in_bug($self);
- }
-
- # Update bug ignore data if user wants to ignore mail for this bug
- if (exists $self->{'bug_ignored'}) {
- my $bug_ignored_changed;
- if ($self->{'bug_ignored'} && !$user->is_bug_ignored($self->id)) {
- $dbh->do('INSERT INTO email_bug_ignore
- (user_id, bug_id) VALUES (?, ?)',
- undef, $user->id, $self->id);
- $bug_ignored_changed = 1;
-
- }
- elsif (!$self->{'bug_ignored'} && $user->is_bug_ignored($self->id)) {
- $dbh->do('DELETE FROM email_bug_ignore
- WHERE user_id = ? AND bug_id = ?',
- undef, $user->id, $self->id);
- $bug_ignored_changed = 1;
- }
- delete $user->{bugs_ignored} if $bug_ignored_changed;
- }
-
- $dbh->bz_commit_transaction();
-
- # The only problem with this here is that update() is often called
- # in the middle of a transaction, and if that transaction is rolled
- # back, this change will *not* be rolled back. As we expect rollbacks
- # to be extremely rare, that is OK for us.
- $self->_sync_fulltext(
- update_short_desc => $changes->{short_desc},
- update_comments => $self->{added_comments} || $self->{comment_isprivate}
+ timestamp => $delta_ts,
+ bug => $self,
+ old_bug => $old_bug,
+ changes => $changes
+ }
+ );
+
+ # Certain items in $changes have to be fixed so that they hold
+ # a name instead of an ID.
+ foreach my $field (qw(product_id component_id)) {
+ my $change = delete $changes->{$field};
+ if ($change) {
+ my $new_field = $field;
+ $new_field =~ s/_id$//;
+ $changes->{$new_field} = [$self->{"_old_${new_field}_name"}, $self->$new_field];
+ }
+ }
+ foreach my $field (qw(qa_contact assigned_to)) {
+ if ($changes->{$field}) {
+ my ($from, $to) = @{$changes->{$field}};
+ $from = $old_bug->$field->login if $from;
+ $to = $self->$field->login if $to;
+ $changes->{$field} = [$from, $to];
+ }
+ }
+
+ # CC
+ my @old_cc = map { $_->id } @{$old_bug->cc_users};
+ my @new_cc = map { $_->id } @{$self->cc_users};
+ my ($removed_cc, $added_cc) = diff_arrays(\@old_cc, \@new_cc);
+
+ if (scalar @$removed_cc) {
+ $dbh->do(
+ 'DELETE FROM cc WHERE bug_id = ? AND ' . $dbh->sql_in('who', $removed_cc),
+ undef, $self->id);
+ }
+ foreach my $user_id (@$added_cc) {
+ $dbh->do('INSERT INTO cc (bug_id, who) VALUES (?,?)',
+ undef, $self->id, $user_id);
+ }
+
+ # If any changes were found, record it in the activity log
+ if (scalar @$removed_cc || scalar @$added_cc) {
+ my $removed_users = Bugzilla::User->new_from_list($removed_cc);
+ my $added_users = Bugzilla::User->new_from_list($added_cc);
+ my $removed_names = join(', ', (map { $_->login } @$removed_users));
+ my $added_names = join(', ', (map { $_->login } @$added_users));
+ $changes->{cc} = [$removed_names, $added_names];
+ }
+
+ # Aliases
+ my $old_aliases = $old_bug->alias;
+ my $new_aliases = $self->alias;
+ my ($removed_aliases, $added_aliases) = diff_arrays($old_aliases, $new_aliases);
+
+ foreach my $alias (@$removed_aliases) {
+ $dbh->do('DELETE FROM bugs_aliases WHERE bug_id = ? AND alias = ?',
+ undef, $self->id, $alias);
+ }
+ foreach my $alias (@$added_aliases) {
+ trick_taint($alias);
+ $dbh->do('INSERT INTO bugs_aliases (bug_id, alias) VALUES (?,?)',
+ undef, $self->id, $alias);
+ }
+
+ # If any changes were found, record it in the activity log
+ if (scalar @$removed_aliases || scalar @$added_aliases) {
+ $changes->{alias}
+ = [join(', ', @$removed_aliases), join(', ', @$added_aliases)];
+ }
+
+ # Keywords
+ my @old_kw_ids = map { $_->id } @{$old_bug->keyword_objects};
+ my @new_kw_ids = map { $_->id } @{$self->keyword_objects};
+
+ my ($removed_kw, $added_kw) = diff_arrays(\@old_kw_ids, \@new_kw_ids);
+
+ if (scalar @$removed_kw) {
+ $dbh->do(
+ 'DELETE FROM keywords WHERE bug_id = ? AND '
+ . $dbh->sql_in('keywordid', $removed_kw),
+ undef, $self->id
);
-
- # Remove obsolete internal variables.
- delete $self->{'_old_assigned_to'};
- delete $self->{'_old_qa_contact'};
-
- # Also flush the visible_bugs cache for this bug as the user's
- # relationship with this bug may have changed.
- delete $user->{_visible_bugs_cache}->{$self->id};
-
- return $changes;
+ }
+ foreach my $keyword_id (@$added_kw) {
+ $dbh->do('INSERT INTO keywords (bug_id, keywordid) VALUES (?,?)',
+ undef, $self->id, $keyword_id);
+ }
+
+ # If any changes were found, record it in the activity log
+ if (scalar @$removed_kw || scalar @$added_kw) {
+ my $removed_keywords = Bugzilla::Keyword->new_from_list($removed_kw);
+ my $added_keywords = Bugzilla::Keyword->new_from_list($added_kw);
+ my $removed_names = join(', ', (map { $_->name } @$removed_keywords));
+ my $added_names = join(', ', (map { $_->name } @$added_keywords));
+ $changes->{keywords} = [$removed_names, $added_names];
+ }
+
+ # Dependencies
+ foreach my $pair ([qw(dependson blocked)], [qw(blocked dependson)]) {
+ my ($type, $other) = @$pair;
+ my $old = $old_bug->$type;
+ my $new = $self->$type;
+
+ my ($removed, $added) = diff_arrays($old, $new);
+ foreach my $removed_id (@$removed) {
+ $dbh->do("DELETE FROM dependencies WHERE $type = ? AND $other = ?",
+ undef, $removed_id, $self->id);
+
+ # Add an activity entry for the other bug.
+ LogActivityEntry($removed_id, $other, $self->id, '', $user->id, $delta_ts);
+
+ # Update delta_ts on the other bug so that we trigger mid-airs.
+ $dbh->do('UPDATE bugs SET delta_ts = ? WHERE bug_id = ?',
+ undef, $delta_ts, $removed_id);
+ }
+ foreach my $added_id (@$added) {
+ $dbh->do("INSERT INTO dependencies ($type, $other) VALUES (?,?)",
+ undef, $added_id, $self->id);
+
+ # Add an activity entry for the other bug.
+ LogActivityEntry($added_id, $other, '', $self->id, $user->id, $delta_ts);
+
+ # Update delta_ts on the other bug so that we trigger mid-airs.
+ $dbh->do('UPDATE bugs SET delta_ts = ? WHERE bug_id = ?',
+ undef, $delta_ts, $added_id);
+ }
+
+ if (scalar(@$removed) || scalar(@$added)) {
+ $changes->{$type} = [join(', ', @$removed), join(', ', @$added)];
+ }
+ }
+
+ # Groups
+ my %old_groups = map { $_->id => $_ } @{$old_bug->groups_in};
+ my %new_groups = map { $_->id => $_ } @{$self->groups_in};
+ my ($removed_gr, $added_gr)
+ = diff_arrays([keys %old_groups], [keys %new_groups]);
+ if (scalar @$removed_gr || scalar @$added_gr) {
+ if (@$removed_gr) {
+ my $qmarks = join(',', ('?') x @$removed_gr);
+ $dbh->do(
+ "DELETE FROM bug_group_map
+ WHERE bug_id = ? AND group_id IN ($qmarks)", undef, $self->id,
+ @$removed_gr
+ );
+ }
+ my $sth_insert
+ = $dbh->prepare('INSERT INTO bug_group_map (bug_id, group_id) VALUES (?,?)');
+ foreach my $gid (@$added_gr) {
+ $sth_insert->execute($self->id, $gid);
+ }
+ my @removed_names = map { $old_groups{$_}->name } @$removed_gr;
+ my @added_names = map { $new_groups{$_}->name } @$added_gr;
+ $changes->{'bug_group'}
+ = [join(', ', @removed_names), join(', ', @added_names)];
+ }
+
+ # Comments
+ foreach my $comment (@{$self->{added_comments} || []}) {
+
+ # Override the Comment's timestamp to be identical to the update
+ # timestamp.
+ $comment->{bug_when} = $delta_ts;
+ $comment = Bugzilla::Comment->insert_create_data($comment);
+ if ($comment->work_time) {
+ LogActivityEntry($self->id, "work_time", "", $comment->work_time, $user->id,
+ $delta_ts);
+ }
+ }
+
+ # Comment Privacy
+ foreach my $comment (@{$self->{comment_isprivate} || []}) {
+ $comment->update();
+
+ my ($from, $to) = $comment->is_private ? (0, 1) : (1, 0);
+ LogActivityEntry($self->id, "longdescs.isprivate", $from, $to, $user->id,
+ $delta_ts, $comment->id);
+ }
+
+ # Clear the cache of comments
+ delete $self->{comments};
+
+ # Insert the values into the multiselect value tables
+ my @multi_selects
+ = grep { $_->type == FIELD_TYPE_MULTI_SELECT } Bugzilla->active_custom_fields;
+ foreach my $field (@multi_selects) {
+ my $name = $field->name;
+ my ($removed, $added) = diff_arrays($old_bug->$name, $self->$name);
+ if (scalar @$removed || scalar @$added) {
+ $changes->{$name} = [join(', ', @$removed), join(', ', @$added)];
+
+ $dbh->do("DELETE FROM bug_$name where bug_id = ?", undef, $self->id);
+ foreach my $value (@{$self->$name}) {
+ $dbh->do("INSERT INTO bug_$name (bug_id, value) VALUES (?,?)",
+ undef, $self->id, $value);
+ }
+ }
+ }
+
+ # See Also
+
+ my ($removed_see, $added_see)
+ = diff_arrays($old_bug->see_also, $self->see_also, 'name');
+
+ $_->remove_from_db foreach @$removed_see;
+ $_->insert_create_data($_) foreach @$added_see;
+
+ # If any changes were found, record it in the activity log
+ if (scalar @$removed_see || scalar @$added_see) {
+ $changes->{see_also} = [
+ join(', ', map { $_->name } @$removed_see),
+ join(', ', map { $_->name } @$added_see)
+ ];
+ }
+
+ # Flags
+ my ($removed, $added)
+ = Bugzilla::Flag->update_flags($self, $old_bug, $delta_ts);
+ if ($removed || $added) {
+ $changes->{'flagtypes.name'} = [$removed, $added];
+ }
+
+ $_->update foreach @{$self->{_update_ref_bugs} || []};
+ delete $self->{_update_ref_bugs};
+
+ # Log bugs_activity items
+ # XXX Eventually, when bugs_activity is able to track the dupe_id,
+ # this code should go below the duplicates-table-updating code below.
+ foreach my $field (keys %$changes) {
+ my $change = $changes->{$field};
+ my $from = defined $change->[0] ? $change->[0] : '';
+ my $to = defined $change->[1] ? $change->[1] : '';
+ LogActivityEntry($self->id, $field, $from, $to, $user->id, $delta_ts);
+ }
+
+ # Check if we have to update the duplicates table and the other bug.
+ my ($old_dup, $cur_dup) = ($old_bug->dup_id || 0, $self->dup_id || 0);
+ if ($old_dup != $cur_dup) {
+ $dbh->do("DELETE FROM duplicates WHERE dupe = ?", undef, $self->id);
+ if ($cur_dup) {
+ $dbh->do('INSERT INTO duplicates (dupe, dupe_of) VALUES (?,?)',
+ undef, $self->id, $cur_dup);
+ if (my $update_dup = delete $self->{_dup_for_update}) {
+ $update_dup->update();
+ }
+ }
+
+ $changes->{'dup_id'} = [$old_dup || undef, $cur_dup || undef];
+ }
+
+ Bugzilla::Hook::process(
+ 'bug_end_of_update',
+ {
+ bug => $self,
+ timestamp => $delta_ts,
+ changes => $changes,
+ old_bug => $old_bug
+ }
+ );
+
+ # If any change occurred, refresh the timestamp of the bug.
+ if ( scalar(keys %$changes)
+ || $self->{added_comments}
+ || $self->{comment_isprivate})
+ {
+ $dbh->do('UPDATE bugs SET delta_ts = ? WHERE bug_id = ?',
+ undef, ($delta_ts, $self->id));
+ $self->{delta_ts} = $delta_ts;
+ }
+
+ # Update last-visited
+ if ($user->is_involved_in_bug($self)) {
+ $self->update_user_last_visit($user, $delta_ts);
+ }
+
+ # If a user is no longer involved, remove their last visit entry
+ my $last_visits = Bugzilla::BugUserLastVisit->match({bug_id => $self->id});
+ foreach my $lv (@$last_visits) {
+ $lv->remove_from_db() unless $lv->user->is_involved_in_bug($self);
+ }
+
+ # Update bug ignore data if user wants to ignore mail for this bug
+ if (exists $self->{'bug_ignored'}) {
+ my $bug_ignored_changed;
+ if ($self->{'bug_ignored'} && !$user->is_bug_ignored($self->id)) {
+ $dbh->do(
+ 'INSERT INTO email_bug_ignore
+ (user_id, bug_id) VALUES (?, ?)', undef, $user->id, $self->id
+ );
+ $bug_ignored_changed = 1;
+
+ }
+ elsif (!$self->{'bug_ignored'} && $user->is_bug_ignored($self->id)) {
+ $dbh->do(
+ 'DELETE FROM email_bug_ignore
+ WHERE user_id = ? AND bug_id = ?', undef, $user->id, $self->id
+ );
+ $bug_ignored_changed = 1;
+ }
+ delete $user->{bugs_ignored} if $bug_ignored_changed;
+ }
+
+ $self->_sync_fulltext(
+ update_short_desc => $changes->{short_desc},
+ update_comments => $self->{added_comments} || $self->{comment_isprivate}
+ );
+
+ $dbh->bz_commit_transaction();
+
+ # Remove obsolete internal variables.
+ delete $self->{'_old_assigned_to'};
+ delete $self->{'_old_qa_contact'};
+
+ # Also flush the visible_bugs cache for this bug as the user's
+ # relationship with this bug may have changed.
+ delete $user->{_visible_bugs_cache}->{$self->id};
+
+ return $changes;
}
# Used by create().
# We need to handle multi-select fields differently than normal fields,
# because they're arrays and don't go into the bugs table.
sub _extract_multi_selects {
- my ($invocant, $params) = @_;
-
- my @multi_selects = grep {$_->type == FIELD_TYPE_MULTI_SELECT}
- Bugzilla->active_custom_fields;
- my %ms_values;
- foreach my $field (@multi_selects) {
- my $name = $field->name;
- if (exists $params->{$name}) {
- my $array = delete($params->{$name}) || [];
- $ms_values{$name} = $array;
- }
+ my ($invocant, $params) = @_;
+
+ my @multi_selects
+ = grep { $_->type == FIELD_TYPE_MULTI_SELECT } Bugzilla->active_custom_fields;
+ my %ms_values;
+ foreach my $field (@multi_selects) {
+ my $name = $field->name;
+ if (exists $params->{$name}) {
+ my $array = delete($params->{$name}) || [];
+ $ms_values{$name} = $array;
}
- return \%ms_values;
+ }
+ return \%ms_values;
}
# Should be called any time you update short_desc or change a comment.
sub _sync_fulltext {
- my ($self, %options) = @_;
- my $dbh = Bugzilla->dbh;
-
- my($all_comments, $public_comments);
- if ($options{new_bug} || $options{update_comments}) {
- my $comments = $dbh->selectall_arrayref(
- 'SELECT thetext, isprivate FROM longdescs WHERE bug_id = ?',
- undef, $self->id);
- $all_comments = join("\n", map { $_->[0] } @$comments);
- my @no_private = grep { !$_->[1] } @$comments;
- $public_comments = join("\n", map { $_->[0] } @no_private);
- }
-
- if ($options{new_bug}) {
- $dbh->do('INSERT INTO bugs_fulltext (bug_id, short_desc, comments,
+ my ($self, %options) = @_;
+ my $dbh = Bugzilla->dbh;
+
+ my ($all_comments, $public_comments);
+ if ($options{new_bug} || $options{update_comments}) {
+ my $comments
+ = $dbh->selectall_arrayref(
+ 'SELECT thetext, isprivate FROM longdescs WHERE bug_id = ?',
+ undef, $self->id);
+ $all_comments = join("\n", map { $_->[0] } @$comments);
+ my @no_private = grep { !$_->[1] } @$comments;
+ $public_comments = join("\n", map { $_->[0] } @no_private);
+ }
+
+ if ($options{new_bug}) {
+ $dbh->do(
+ 'INSERT INTO bugs_fulltext (bug_id, short_desc, comments,
comments_noprivate)
- VALUES (?, ?, ?, ?)',
- undef,
- $self->id, $self->short_desc, $all_comments, $public_comments);
- } else {
- my(@names, @values);
- if ($options{update_short_desc}) {
- push @names, 'short_desc';
- push @values, $self->short_desc;
- }
- if ($options{update_comments}) {
- push @names, ('comments', 'comments_noprivate');
- push @values, ($all_comments, $public_comments);
- }
- if (@names) {
- $dbh->do('UPDATE bugs_fulltext SET ' .
- join(', ', map { "$_ = ?" } @names) .
- ' WHERE bug_id = ?',
- undef,
- @values, $self->id);
- }
+ VALUES (?, ?, ?, ?)', undef, $self->id, $self->short_desc,
+ $all_comments, $public_comments
+ );
+ }
+ else {
+ my (@names, @values);
+ if ($options{update_short_desc}) {
+ push @names, 'short_desc';
+ push @values, $self->short_desc;
}
+ if ($options{update_comments}) {
+ push @names, ('comments', 'comments_noprivate');
+ push @values, ($all_comments, $public_comments);
+ }
+ if (@names) {
+ $dbh->do(
+ 'UPDATE bugs_fulltext SET '
+ . join(', ', map {"$_ = ?"} @names)
+ . ' WHERE bug_id = ?',
+ undef, @values, $self->id
+ );
+ }
+ }
}
sub remove_from_db {
- my ($self) = @_;
- my $dbh = Bugzilla->dbh;
+ my ($self) = @_;
+ my $dbh = Bugzilla->dbh;
+
+ ThrowCodeError("bug_error", {bug => $self}) if $self->{'error'};
- ThrowCodeError("bug_error", { bug => $self }) if $self->{'error'};
+ my $bug_id = $self->{'bug_id'};
+ $self->SUPER::remove_from_db();
- my $bug_id = $self->{'bug_id'};
- $self->SUPER::remove_from_db();
- # The bugs_fulltext table doesn't support foreign keys.
- $dbh->do("DELETE FROM bugs_fulltext WHERE bug_id = ?", undef, $bug_id);
+ # The bugs_fulltext table doesn't support foreign keys.
+ $dbh->do("DELETE FROM bugs_fulltext WHERE bug_id = ?", undef, $bug_id);
}
#####################################################################
@@ -1272,96 +1308,93 @@ sub remove_from_db {
#####################################################################
sub send_changes {
- my ($self, $changes, $vars) = @_;
-
- my $user = Bugzilla->user;
-
- my $old_qa = $changes->{'qa_contact'}
- ? $changes->{'qa_contact'}->[0] : '';
- my $old_own = $changes->{'assigned_to'}
- ? $changes->{'assigned_to'}->[0] : '';
- my $old_cc = $changes->{cc}
- ? $changes->{cc}->[0] : '';
-
- my %forced = (
- cc => [split(/[,;]+/, $old_cc)],
- owner => $old_own,
- qacontact => $old_qa,
- changer => $user,
- );
-
- _send_bugmail({ id => $self->id, type => 'bug', forced => \%forced },
- $vars);
-
- # If the bug was marked as a duplicate, we need to notify users on the
- # other bug of any changes to that bug.
- my $new_dup_id = $changes->{'dup_id'} ? $changes->{'dup_id'}->[1] : undef;
- if ($new_dup_id) {
- _send_bugmail({ forced => { changer => $user }, type => "dupe",
- id => $new_dup_id }, $vars);
- }
-
- # If there were changes in dependencies, we need to notify those
- # dependencies.
- if ($changes->{'bug_status'}) {
- my ($old_status, $new_status) = @{ $changes->{'bug_status'} };
-
- # If this bug has changed from opened to closed or vice-versa,
- # then all of the bugs we block need to be notified.
- if (is_open_state($old_status) ne is_open_state($new_status)) {
- my $params = { forced => { changer => $user },
- type => 'dep',
- dep_only => 1,
- blocker => $self,
- changes => $changes };
-
- foreach my $id (@{ $self->blocked }) {
- $params->{id} = $id;
- _send_bugmail($params, $vars);
- }
- }
- }
-
- # To get a list of all changed dependencies, convert the "changes" arrays
- # into a long string, then collapse that string into unique numbers in
- # a hash.
- my $all_changed_deps = join(', ', @{ $changes->{'dependson'} || [] });
- $all_changed_deps = join(', ', @{ $changes->{'blocked'} || [] },
- $all_changed_deps);
- my %changed_deps = map { $_ => 1 } split(', ', $all_changed_deps);
- # When clearning one field (say, blocks) and filling in the other
- # (say, dependson), an empty string can get into the hash and cause
- # an error later.
- delete $changed_deps{''};
-
- foreach my $id (sort { $a <=> $b } (keys %changed_deps)) {
- _send_bugmail({ forced => { changer => $user }, type => "dep",
- id => $id }, $vars);
- }
-
- # Sending emails for the referenced bugs.
- foreach my $ref_bug_id (uniq @{ $self->{see_also_changes} || [] }) {
- _send_bugmail({ forced => { changer => $user },
- id => $ref_bug_id }, $vars);
- }
+ my ($self, $changes, $vars) = @_;
+
+ my $user = Bugzilla->user;
+
+ my $old_qa = $changes->{'qa_contact'} ? $changes->{'qa_contact'}->[0] : '';
+ my $old_own = $changes->{'assigned_to'} ? $changes->{'assigned_to'}->[0] : '';
+ my $old_cc = $changes->{cc} ? $changes->{cc}->[0] : '';
+
+ my %forced = (
+ cc => [split(/[,;]+/, $old_cc)],
+ owner => $old_own,
+ qacontact => $old_qa,
+ changer => $user,
+ );
+
+ _send_bugmail({id => $self->id, type => 'bug', forced => \%forced}, $vars);
+
+ # If the bug was marked as a duplicate, we need to notify users on the
+ # other bug of any changes to that bug.
+ my $new_dup_id = $changes->{'dup_id'} ? $changes->{'dup_id'}->[1] : undef;
+ if ($new_dup_id) {
+ _send_bugmail({forced => {changer => $user}, type => "dupe", id => $new_dup_id},
+ $vars);
+ }
+
+ # If there were changes in dependencies, we need to notify those
+ # dependencies.
+ if ($changes->{'bug_status'}) {
+ my ($old_status, $new_status) = @{$changes->{'bug_status'}};
+
+ # If this bug has changed from opened to closed or vice-versa,
+ # then all of the bugs we block need to be notified.
+ if (is_open_state($old_status) ne is_open_state($new_status)) {
+ my $params = {
+ forced => {changer => $user},
+ type => 'dep',
+ dep_only => 1,
+ blocker => $self,
+ changes => $changes
+ };
+
+ foreach my $id (@{$self->blocked}) {
+ $params->{id} = $id;
+ _send_bugmail($params, $vars);
+ }
+ }
+ }
+
+ # To get a list of all changed dependencies, convert the "changes" arrays
+ # into a long string, then collapse that string into unique numbers in
+ # a hash.
+ my $all_changed_deps = join(', ', @{$changes->{'dependson'} || []});
+ $all_changed_deps
+ = join(', ', @{$changes->{'blocked'} || []}, $all_changed_deps);
+ my %changed_deps = map { $_ => 1 } split(', ', $all_changed_deps);
+
+ # When clearning one field (say, blocks) and filling in the other
+ # (say, dependson), an empty string can get into the hash and cause
+ # an error later.
+ delete $changed_deps{''};
+
+ foreach my $id (sort { $a <=> $b } (keys %changed_deps)) {
+ _send_bugmail({forced => {changer => $user}, type => "dep", id => $id}, $vars);
+ }
+
+ # Sending emails for the referenced bugs.
+ foreach my $ref_bug_id (uniq @{$self->{see_also_changes} || []}) {
+ _send_bugmail({forced => {changer => $user}, id => $ref_bug_id}, $vars);
+ }
}
sub _send_bugmail {
- my ($params, $vars) = @_;
+ my ($params, $vars) = @_;
- require Bugzilla::BugMail;
+ require Bugzilla::BugMail;
- my $results =
- Bugzilla::BugMail::Send($params->{'id'}, $params->{'forced'}, $params);
+ my $results
+ = Bugzilla::BugMail::Send($params->{'id'}, $params->{'forced'}, $params);
- if (Bugzilla->usage_mode == USAGE_MODE_BROWSER) {
- my $template = Bugzilla->template;
- $vars->{$_} = $params->{$_} foreach keys %$params;
- $vars->{'sent_bugmail'} = $results;
- $template->process("bug/process/results.html.tmpl", $vars)
- || ThrowTemplateError($template->error());
- $vars->{'header_done'} = 1;
- }
+ if (Bugzilla->usage_mode == USAGE_MODE_BROWSER) {
+ my $template = Bugzilla->template;
+ $vars->{$_} = $params->{$_} foreach keys %$params;
+ $vars->{'sent_bugmail'} = $results;
+ $template->process("bug/process/results.html.tmpl", $vars)
+ || ThrowTemplateError($template->error());
+ $vars->{'header_done'} = 1;
+ }
}
#####################################################################
@@ -1369,928 +1402,956 @@ sub _send_bugmail {
#####################################################################
sub _check_alias {
- my ($invocant, $aliases) = @_;
- $aliases = ref $aliases ? $aliases : [split(/[\s,]+/, $aliases)];
+ my ($invocant, $aliases) = @_;
+ $aliases = ref $aliases ? $aliases : [split(/[\s,]+/, $aliases)];
- # Remove empty aliases
- @$aliases = grep { $_ } @$aliases;
+ # Remove empty aliases
+ @$aliases = grep {$_} @$aliases;
- foreach my $alias (@$aliases) {
- $alias = trim($alias);
+ foreach my $alias (@$aliases) {
+ $alias = trim($alias);
- # Make sure the alias isn't too long.
- if (length($alias) > 40) {
- ThrowUserError("alias_too_long");
- }
- # Make sure the alias isn't just a number.
- if ($alias =~ /^\d+$/) {
- ThrowUserError("alias_is_numeric", { alias => $alias });
- }
- # Make sure the alias has no commas or spaces.
- if ($alias =~ /[, ]/) {
- ThrowUserError("alias_has_comma_or_space", { alias => $alias });
- }
- # Make sure the alias is unique, or that it's already our alias.
- my $other_bug = new Bugzilla::Bug($alias);
- if (!$other_bug->{error}
- && (!ref $invocant || $other_bug->id != $invocant->id))
- {
- ThrowUserError("alias_in_use", { alias => $alias,
- bug_id => $other_bug->id });
- }
+ # Make sure the alias isn't too long.
+ if (length($alias) > 40) {
+ ThrowUserError("alias_too_long");
}
- return $aliases;
-}
+ # Make sure the alias isn't just a number.
+ if ($alias =~ /^\d+$/) {
+ ThrowUserError("alias_is_numeric", {alias => $alias});
+ }
-sub _check_assigned_to {
- my ($invocant, $assignee, undef, $params) = @_;
- my $user = Bugzilla->user;
- my $component = blessed($invocant) ? $invocant->component_obj
- : $params->{component};
-
- # Default assignee is the component owner.
- my $id;
- # If this is a new bug, you can only set the assignee if you have editbugs.
- # If you didn't specify the assignee, we use the default assignee.
- if (!ref $invocant
- && (!$user->in_group('editbugs', $component->product_id) || !$assignee))
+ # Make sure the alias has no commas or spaces.
+ if ($alias =~ /[, ]/) {
+ ThrowUserError("alias_has_comma_or_space", {alias => $alias});
+ }
+
+ # Make sure the alias is unique, or that it's already our alias.
+ my $other_bug = new Bugzilla::Bug($alias);
+ if (!$other_bug->{error} && (!ref $invocant || $other_bug->id != $invocant->id))
{
- $id = $component->default_assignee->id;
- } else {
- if (!ref $assignee) {
- $assignee = trim($assignee);
- # When updating a bug, assigned_to can't be empty.
- ThrowUserError("reassign_to_empty") if ref $invocant && !$assignee;
- $assignee = Bugzilla::User->check($assignee);
- }
- $id = $assignee->id;
- # create() checks this another way, so we don't have to run this
- # check during create().
- $invocant->_check_strict_isolation_for_user($assignee) if ref $invocant;
+ ThrowUserError("alias_in_use", {alias => $alias, bug_id => $other_bug->id});
}
- return $id;
+ }
+
+ return $aliases;
}
-sub _check_bug_file_loc {
- my ($invocant, $url) = @_;
- $url = '' if !defined($url);
- $url = trim($url);
- # On bug entry, if bug_file_loc is "http://", the default, use an
- # empty value instead. However, on bug editing people can set that
- # back if they *really* want to.
- if (!ref $invocant && $url eq 'http://') {
- $url = '';
- }
- return $url;
+sub _check_assigned_to {
+ my ($invocant, $assignee, undef, $params) = @_;
+ my $user = Bugzilla->user;
+ my $component
+ = blessed($invocant) ? $invocant->component_obj : $params->{component};
+
+ # Default assignee is the component owner.
+ my $id;
+
+ # If this is a new bug, you can only set the assignee if you have editbugs.
+ # If you didn't specify the assignee, we use the default assignee.
+ if (!ref $invocant
+ && (!$user->in_group('editbugs', $component->product_id) || !$assignee))
+ {
+ $id = $component->default_assignee->id;
+ }
+ else {
+ if (!ref $assignee) {
+ $assignee = trim($assignee);
+
+ # When updating a bug, assigned_to can't be empty.
+ ThrowUserError("reassign_to_empty") if ref $invocant && !$assignee;
+ $assignee = Bugzilla::User->check($assignee);
+ }
+ $id = $assignee->id;
+
+ # create() checks this another way, so we don't have to run this
+ # check during create().
+ $invocant->_check_strict_isolation_for_user($assignee) if ref $invocant;
+ }
+ return $id;
}
-sub _check_bug_status {
- my ($invocant, $new_status, undef, $params) = @_;
- my $user = Bugzilla->user;
- my @valid_statuses;
- my $old_status; # Note that this is undef for new bugs.
+sub _check_bug_file_loc {
+ my ($invocant, $url) = @_;
+ $url = '' if !defined($url);
+ $url = trim($url);
- my ($product, $comment);
- if (ref $invocant) {
- @valid_statuses = @{$invocant->statuses_available};
- $product = $invocant->product_obj;
- $old_status = $invocant->status;
- my $comments = $invocant->{added_comments} || [];
- $comment = $comments->[-1];
- }
- else {
- $product = $params->{product};
- $comment = $params->{comment};
- @valid_statuses = @{ Bugzilla::Bug->statuses_available($product) };
- }
+ # On bug entry, if bug_file_loc is "http://", the default, use an
+ # empty value instead. However, on bug editing people can set that
+ # back if they *really* want to.
+ if (!ref $invocant && $url eq 'http://') {
+ $url = '';
+ }
+ return $url;
+}
- # Check permissions for users filing new bugs.
- if (!ref $invocant) {
- if ($user->in_group('editbugs', $product->id)
- || $user->in_group('canconfirm', $product->id)) {
- # If the user with privs hasn't selected another status,
- # select the first one of the list.
- unless ($new_status) {
- if (scalar(@valid_statuses) == 1) {
- $new_status = $valid_statuses[0];
- }
- else {
- $new_status = ($valid_statuses[0]->name ne 'UNCONFIRMED') ?
- $valid_statuses[0] : $valid_statuses[1];
- }
- }
+sub _check_bug_status {
+ my ($invocant, $new_status, undef, $params) = @_;
+ my $user = Bugzilla->user;
+ my @valid_statuses;
+ my $old_status; # Note that this is undef for new bugs.
+
+ my ($product, $comment);
+ if (ref $invocant) {
+ @valid_statuses = @{$invocant->statuses_available};
+ $product = $invocant->product_obj;
+ $old_status = $invocant->status;
+ my $comments = $invocant->{added_comments} || [];
+ $comment = $comments->[-1];
+ }
+ else {
+ $product = $params->{product};
+ $comment = $params->{comment};
+ @valid_statuses = @{Bugzilla::Bug->statuses_available($product)};
+ }
+
+ # Check permissions for users filing new bugs.
+ if (!ref $invocant) {
+ if ( $user->in_group('editbugs', $product->id)
+ || $user->in_group('canconfirm', $product->id))
+ {
+ # If the user with privs hasn't selected another status,
+ # select the first one of the list.
+ unless ($new_status) {
+ if (scalar(@valid_statuses) == 1) {
+ $new_status = $valid_statuses[0];
}
else {
- # A user with no privs cannot choose the initial status.
- # If UNCONFIRMED is valid for this product, use it; else
- # use the first bug status available.
- if (grep {$_->name eq 'UNCONFIRMED'} @valid_statuses) {
- $new_status = 'UNCONFIRMED';
- }
- else {
- $new_status = $valid_statuses[0];
- }
+ $new_status
+ = ($valid_statuses[0]->name ne 'UNCONFIRMED')
+ ? $valid_statuses[0]
+ : $valid_statuses[1];
}
+ }
}
+ else {
+ # A user with no privs cannot choose the initial status.
+ # If UNCONFIRMED is valid for this product, use it; else
+ # use the first bug status available.
+ if (grep { $_->name eq 'UNCONFIRMED' } @valid_statuses) {
+ $new_status = 'UNCONFIRMED';
+ }
+ else {
+ $new_status = $valid_statuses[0];
+ }
+ }
+ }
+
+ # Time to validate the bug status.
+ $new_status = Bugzilla::Status->check($new_status) unless ref($new_status);
+
+ # We skip this check if we are changing from a status to itself.
+ if ((!$old_status || $old_status->id != $new_status->id)
+ && !grep { $_->name eq $new_status->name } @valid_statuses)
+ {
+ ThrowUserError('illegal_bug_status_transition',
+ {old => $old_status, new => $new_status});
+ }
+
+ # Check if a comment is required for this change.
+ if ($new_status->comment_required_on_change_from($old_status)
+ && !$comment->{'thetext'})
+ {
+ ThrowUserError(
+ 'comment_required',
+ {
+ old => $old_status ? $old_status->name : undef,
+ new => $new_status->name,
+ field => 'bug_status'
+ }
+ );
+ }
- # Time to validate the bug status.
- $new_status = Bugzilla::Status->check($new_status) unless ref($new_status);
- # We skip this check if we are changing from a status to itself.
- if ( (!$old_status || $old_status->id != $new_status->id)
- && !grep {$_->name eq $new_status->name} @valid_statuses)
- {
- ThrowUserError('illegal_bug_status_transition',
- { old => $old_status, new => $new_status });
- }
+ if (
+ ref $invocant && (
+ $new_status->name eq 'IN_PROGRESS'
- # Check if a comment is required for this change.
- if ($new_status->comment_required_on_change_from($old_status)
- && !$comment->{'thetext'})
- {
- ThrowUserError('comment_required',
- { old => $old_status ? $old_status->name : undef,
- new => $new_status->name, field => 'bug_status' });
- }
-
- if (ref $invocant
- && ($new_status->name eq 'IN_PROGRESS'
- # Backwards-compat for the old default workflow.
- or $new_status->name eq 'ASSIGNED')
- && Bugzilla->params->{"usetargetmilestone"}
- && Bugzilla->params->{"musthavemilestoneonaccept"}
- # musthavemilestoneonaccept applies only if at least two
- # target milestones are defined for the product.
- && scalar(@{ $product->milestones }) > 1
- && $invocant->target_milestone eq $product->default_milestone)
- {
- ThrowUserError("milestone_required", { bug => $invocant });
- }
+ # Backwards-compat for the old default workflow.
+ or $new_status->name eq 'ASSIGNED'
+ )
+ && Bugzilla->params->{"usetargetmilestone"}
+ && Bugzilla->params->{"musthavemilestoneonaccept"}
- if (!blessed $invocant) {
- $params->{everconfirmed} = $new_status->name eq 'UNCONFIRMED' ? 0 : 1;
- }
+ # musthavemilestoneonaccept applies only if at least two
+ # target milestones are defined for the product.
+ && scalar(@{$product->milestones}) > 1
+ && $invocant->target_milestone eq $product->default_milestone
+ )
+ {
+ ThrowUserError("milestone_required", {bug => $invocant});
+ }
+
+ if (!blessed $invocant) {
+ $params->{everconfirmed} = $new_status->name eq 'UNCONFIRMED' ? 0 : 1;
+ }
- return $new_status->name;
+ return $new_status->name;
}
sub _check_cc {
- my ($invocant, $ccs, undef, $params) = @_;
- my $component = blessed($invocant) ? $invocant->component_obj
- : $params->{component};
- return [map {$_->id} @{$component->initial_cc}] unless $ccs;
-
- # Allow comma-separated input as well as arrayrefs.
- $ccs = [split(/[,;]+/, $ccs)] if !ref $ccs;
-
- my %cc_ids;
- foreach my $person (@$ccs) {
- $person = trim($person);
- next unless $person;
- my $id = login_to_id($person, THROW_ERROR);
- $cc_ids{$id} = 1;
- }
+ my ($invocant, $ccs, undef, $params) = @_;
+ my $component
+ = blessed($invocant) ? $invocant->component_obj : $params->{component};
+ return [map { $_->id } @{$component->initial_cc}] unless $ccs;
+
+ # Allow comma-separated input as well as arrayrefs.
+ $ccs = [split(/[,;]+/, $ccs)] if !ref $ccs;
+
+ my %cc_ids;
+ foreach my $person (@$ccs) {
+ $person = trim($person);
+ next unless $person;
+ my $id = login_to_id($person, THROW_ERROR);
+ $cc_ids{$id} = 1;
+ }
- # Enforce Default CC
- $cc_ids{$_->id} = 1 foreach (@{$component->initial_cc});
+ # Enforce Default CC
+ $cc_ids{$_->id} = 1 foreach (@{$component->initial_cc});
- return [keys %cc_ids];
+ return [keys %cc_ids];
}
sub _check_comment {
- my ($invocant, $comment_txt, undef, $params) = @_;
+ my ($invocant, $comment_txt, undef, $params) = @_;
- # Comment can be empty. We should force it to be empty if the text is undef
- if (!defined $comment_txt) {
- $comment_txt = '';
- }
+ # Comment can be empty. We should force it to be empty if the text is undef
+ if (!defined $comment_txt) {
+ $comment_txt = '';
+ }
- # Load up some data
- my $isprivate = delete $params->{comment_is_private};
- my $timestamp = $params->{creation_ts};
+ # Load up some data
+ my $isprivate = delete $params->{comment_is_private};
+ my $timestamp = $params->{creation_ts};
- # Create the new comment so we can check it
- my $comment = {
- thetext => $comment_txt,
- bug_when => $timestamp,
- };
+ # Create the new comment so we can check it
+ my $comment = {thetext => $comment_txt, bug_when => $timestamp,};
- # We don't include the "isprivate" column unless it was specified.
- # This allows it to fall back to its database default.
- if (defined $isprivate) {
- $comment->{isprivate} = $isprivate;
- }
+ # We don't include the "isprivate" column unless it was specified.
+ # This allows it to fall back to its database default.
+ if (defined $isprivate) {
+ $comment->{isprivate} = $isprivate;
+ }
- # Validate comment. We have to do this special as a comment normally
- # requires a bug to be already created. For a new bug, the first comment
- # obviously can't get the bug if the bug is created after this
- # (see bug 590334)
- Bugzilla::Comment->check_required_create_fields($comment);
- $comment = Bugzilla::Comment->run_create_validators($comment,
- { skip => ['bug_id'] }
- );
+ # Validate comment. We have to do this special as a comment normally
+ # requires a bug to be already created. For a new bug, the first comment
+ # obviously can't get the bug if the bug is created after this
+ # (see bug 590334)
+ Bugzilla::Comment->check_required_create_fields($comment);
+ $comment
+ = Bugzilla::Comment->run_create_validators($comment, {skip => ['bug_id']});
- return $comment;
+ return $comment;
}
sub _check_commenton {
- my ($invocant, $new_value, $field, $params) = @_;
+ my ($invocant, $new_value, $field, $params) = @_;
- my $has_comment =
- ref($invocant) ? $invocant->{added_comments}
- : (defined $params->{comment}
- and $params->{comment}->{thetext} ne '');
+ my $has_comment
+ = ref($invocant)
+ ? $invocant->{added_comments}
+ : (defined $params->{comment} and $params->{comment}->{thetext} ne '');
- my $is_changing = ref($invocant) ? $invocant->$field ne $new_value
- : $new_value ne '';
+ my $is_changing
+ = ref($invocant) ? $invocant->$field ne $new_value : $new_value ne '';
- if ($is_changing && !$has_comment) {
- my $old_value = ref($invocant) ? $invocant->$field : undef;
- ThrowUserError('comment_required',
- { field => $field, old => $old_value, new => $new_value });
- }
+ if ($is_changing && !$has_comment) {
+ my $old_value = ref($invocant) ? $invocant->$field : undef;
+ ThrowUserError('comment_required',
+ {field => $field, old => $old_value, new => $new_value});
+ }
}
sub _check_component {
- my ($invocant, $name, undef, $params) = @_;
- $name = trim($name);
- $name || ThrowUserError("require_component");
- my $product = blessed($invocant) ? $invocant->product_obj
- : $params->{product};
- my $old_comp = blessed($invocant) ? $invocant->component : '';
- my $object = Bugzilla::Component->check({ product => $product, name => $name });
- if ($object->name ne $old_comp && !$object->is_active) {
- ThrowUserError('value_inactive', { class => ref($object), value => $name });
- }
- return $object;
+ my ($invocant, $name, undef, $params) = @_;
+ $name = trim($name);
+ $name || ThrowUserError("require_component");
+ my $product = blessed($invocant) ? $invocant->product_obj : $params->{product};
+ my $old_comp = blessed($invocant) ? $invocant->component : '';
+ my $object = Bugzilla::Component->check({product => $product, name => $name});
+ if ($object->name ne $old_comp && !$object->is_active) {
+ ThrowUserError('value_inactive', {class => ref($object), value => $name});
+ }
+ return $object;
}
sub _check_creation_ts {
- return Bugzilla->dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)');
+ return Bugzilla->dbh->selectrow_array('SELECT LOCALTIMESTAMP(0)');
}
sub _check_deadline {
- my ($invocant, $date) = @_;
+ my ($invocant, $date) = @_;
- # When filing bugs, we're forgiving and just return undef if
- # the user isn't a timetracker. When updating bugs, check_can_change_field
- # controls permissions, so we don't want to check them here.
- if (!ref $invocant and !Bugzilla->user->is_timetracker) {
- return undef;
- }
+ # When filing bugs, we're forgiving and just return undef if
+ # the user isn't a timetracker. When updating bugs, check_can_change_field
+ # controls permissions, so we don't want to check them here.
+ if (!ref $invocant and !Bugzilla->user->is_timetracker) {
+ return undef;
+ }
- # Validate entered deadline
- $date = trim($date);
- return undef if !$date;
- validate_date($date)
- || ThrowUserError('illegal_date', { date => $date,
- format => 'YYYY-MM-DD' });
- return $date;
+ # Validate entered deadline
+ $date = trim($date);
+ return undef if !$date;
+ validate_date($date)
+ || ThrowUserError('illegal_date', {date => $date, format => 'YYYY-MM-DD'});
+ return $date;
}
# Takes two comma/space-separated strings and returns arrayrefs
# of valid bug IDs.
sub _check_dependencies {
- my ($invocant, $value, $field, $params) = @_;
+ my ($invocant, $value, $field, $params) = @_;
- return $value if $params->{_dependencies_validated};
+ return $value if $params->{_dependencies_validated};
- if (!ref $invocant) {
- # Only editbugs users can set dependencies on bug entry.
- return ([], []) unless Bugzilla->user->in_group(
- 'editbugs', $params->{product}->id);
- }
+ if (!ref $invocant) {
+
+ # Only editbugs users can set dependencies on bug entry.
+ return ([], [])
+ unless Bugzilla->user->in_group('editbugs', $params->{product}->id);
+ }
- # This is done this way so that dependson and blocked can be in
- # VALIDATORS, meaning that they can be in VALIDATOR_DEPENDENCIES,
- # which means that they can be checked in the right order during
- # bug creation.
- my $opposite = $field eq 'dependson' ? 'blocked' : 'dependson';
- my %deps_in = ($field => $value || '',
- $opposite => $params->{$opposite} || '');
-
- foreach my $type (qw(dependson blocked)) {
- my @bug_ids = ref($deps_in{$type})
- ? @{$deps_in{$type}}
- : split(/[\s,]+/, $deps_in{$type});
- # Eliminate nulls.
- @bug_ids = grep {$_} @bug_ids;
-
- my @check_access = @bug_ids;
- # When we're updating a bug, only added or removed bug_ids are
- # checked for whether or not we can see/edit those bugs.
- if (ref $invocant) {
- my $old = $invocant->$type;
- my ($removed, $added) = diff_arrays($old, \@bug_ids);
- @check_access = (@$added, @$removed);
-
- # Check field permissions if we've changed anything.
- if (@check_access) {
- my $privs;
- if (!$invocant->check_can_change_field($type, 0, 1, \$privs)) {
- ThrowUserError('illegal_change', { field => $type,
- privs => $privs });
- }
- }
+ # This is done this way so that dependson and blocked can be in
+ # VALIDATORS, meaning that they can be in VALIDATOR_DEPENDENCIES,
+ # which means that they can be checked in the right order during
+ # bug creation.
+ my $opposite = $field eq 'dependson' ? 'blocked' : 'dependson';
+ my %deps_in = ($field => $value || '', $opposite => $params->{$opposite} || '');
+
+ foreach my $type (qw(dependson blocked)) {
+ my @bug_ids
+ = ref($deps_in{$type})
+ ? @{$deps_in{$type}}
+ : split(/[\s,]+/, $deps_in{$type});
+
+ # Eliminate nulls.
+ @bug_ids = grep {$_} @bug_ids;
+
+ my @check_access = @bug_ids;
+
+ # When we're updating a bug, only added or removed bug_ids are
+ # checked for whether or not we can see/edit those bugs.
+ if (ref $invocant) {
+ my $old = $invocant->$type;
+ my ($removed, $added) = diff_arrays($old, \@bug_ids);
+ @check_access = (@$added, @$removed);
+
+ # Check field permissions if we've changed anything.
+ if (@check_access) {
+ my $privs;
+ if (!$invocant->check_can_change_field($type, 0, 1, \$privs)) {
+ ThrowUserError('illegal_change', {field => $type, privs => $privs});
}
+ }
+ }
- my $user = Bugzilla->user;
- foreach my $modified_id (@check_access) {
- my $delta_bug = $invocant->check($modified_id);
- # Under strict isolation, you can't modify a bug if you can't
- # edit it, even if you can see it.
- if (Bugzilla->params->{"strict_isolation"}) {
- if (!$user->can_edit_product($delta_bug->{'product_id'})) {
- ThrowUserError("illegal_change_deps", {field => $type});
- }
- }
+ my $user = Bugzilla->user;
+ foreach my $modified_id (@check_access) {
+ my $delta_bug = $invocant->check($modified_id);
+
+ # Under strict isolation, you can't modify a bug if you can't
+ # edit it, even if you can see it.
+ if (Bugzilla->params->{"strict_isolation"}) {
+ if (!$user->can_edit_product($delta_bug->{'product_id'})) {
+ ThrowUserError("illegal_change_deps", {field => $type});
}
- # Replace all aliases by their corresponding bug ID.
- @bug_ids = map { $_ =~ /^(\d+)$/ ? $1 : $invocant->check($_, $type)->id } @bug_ids;
- $deps_in{$type} = \@bug_ids;
+ }
}
- # And finally, check for dependency loops.
- my $bug_id = ref($invocant) ? $invocant->id : 0;
- my %deps = ValidateDependencies($deps_in{dependson}, $deps_in{blocked},
- $bug_id);
+ # Replace all aliases by their corresponding bug ID.
+ @bug_ids
+ = map { $_ =~ /^(\d+)$/ ? $1 : $invocant->check($_, $type)->id } @bug_ids;
+ $deps_in{$type} = \@bug_ids;
+ }
- $params->{$opposite} = $deps{$opposite};
- $params->{_dependencies_validated} = 1;
- return $deps{$field};
+ # And finally, check for dependency loops.
+ my $bug_id = ref($invocant) ? $invocant->id : 0;
+ my %deps
+ = ValidateDependencies($deps_in{dependson}, $deps_in{blocked}, $bug_id);
+
+ $params->{$opposite} = $deps{$opposite};
+ $params->{_dependencies_validated} = 1;
+ return $deps{$field};
}
sub _check_dup_id {
- my ($self, $dupe_of) = @_;
- my $dbh = Bugzilla->dbh;
-
- # Store the bug ID/alias passed by the user for visibility checks.
- my $orig_dupe_of = $dupe_of = trim($dupe_of);
- $dupe_of || ThrowCodeError('undefined_field', { field => 'dup_id' });
- # Validate the bug ID. The second argument will force check() to only
- # make sure that the bug exists, and convert the alias to the bug ID
- # if a string is passed. Group restrictions are checked below.
- my $dupe_of_bug = $self->check($dupe_of, 'dup_id');
- $dupe_of = $dupe_of_bug->id;
-
- # If the dupe is unchanged, we have nothing more to check.
- return $dupe_of if ($self->dup_id && $self->dup_id == $dupe_of);
-
- # If we come here, then the duplicate is new. We have to make sure
- # that we can view/change it (issue A on bug 96085).
- $dupe_of_bug->check_is_visible($orig_dupe_of);
-
- # Make sure a loop isn't created when marking this bug
- # as duplicate.
- _resolve_ultimate_dup_id($self->id, $dupe_of, 1);
-
- my $cur_dup = $self->dup_id || 0;
- if ($cur_dup != $dupe_of && Bugzilla->params->{'commentonduplicate'}
- && !$self->{added_comments})
- {
- ThrowUserError('comment_required');
+ my ($self, $dupe_of) = @_;
+ my $dbh = Bugzilla->dbh;
+
+ # Store the bug ID/alias passed by the user for visibility checks.
+ my $orig_dupe_of = $dupe_of = trim($dupe_of);
+ $dupe_of || ThrowCodeError('undefined_field', {field => 'dup_id'});
+
+ # Validate the bug ID. The second argument will force check() to only
+ # make sure that the bug exists, and convert the alias to the bug ID
+ # if a string is passed. Group restrictions are checked below.
+ my $dupe_of_bug = $self->check($dupe_of, 'dup_id');
+ $dupe_of = $dupe_of_bug->id;
+
+ # If the dupe is unchanged, we have nothing more to check.
+ return $dupe_of if ($self->dup_id && $self->dup_id == $dupe_of);
+
+ # If we come here, then the duplicate is new. We have to make sure
+ # that we can view/change it (issue A on bug 96085).
+ $dupe_of_bug->check_is_visible($orig_dupe_of);
+
+ # Make sure a loop isn't created when marking this bug
+ # as duplicate.
+ _resolve_ultimate_dup_id($self->id, $dupe_of, 1);
+
+ my $cur_dup = $self->dup_id || 0;
+ if ( $cur_dup != $dupe_of
+ && Bugzilla->params->{'commentonduplicate'}
+ && !$self->{added_comments})
+ {
+ ThrowUserError('comment_required');
+ }
+
+ # Should we add the reporter to the CC list of the new bug?
+ # If they can see the bug...
+ if ($self->reporter->can_see_bug($dupe_of)) {
+
+ # We only add them if they're not the reporter of the other bug.
+ $self->{_add_dup_cc} = 1 if $dupe_of_bug->reporter->id != $self->reporter->id;
+ }
+
+ # What if the reporter currently can't see the new bug? In the browser
+ # interface, we prompt the user. In other interfaces, we default to
+ # not adding the user, as the safest option.
+ elsif (Bugzilla->usage_mode == USAGE_MODE_BROWSER) {
+
+ # If we've already confirmed whether the user should be added...
+ my $cgi = Bugzilla->cgi;
+ my $add_confirmed = $cgi->param('confirm_add_duplicate');
+ if (defined $add_confirmed) {
+ $self->{_add_dup_cc} = $add_confirmed;
}
+ else {
+ # Note that here we don't check if the user is already the reporter
+ # of the dupe_of bug, since we already checked if they can *see*
+ # the bug, above. People might have reporter_accessible turned
+ # off, but cclist_accessible turned on, so they might want to
+ # add the reporter even though they're already the reporter of the
+ # dup_of bug.
+ my $vars = {};
+ my $template = Bugzilla->template;
- # Should we add the reporter to the CC list of the new bug?
- # If they can see the bug...
- if ($self->reporter->can_see_bug($dupe_of)) {
- # We only add them if they're not the reporter of the other bug.
- $self->{_add_dup_cc} = 1
- if $dupe_of_bug->reporter->id != $self->reporter->id;
- }
- # What if the reporter currently can't see the new bug? In the browser
- # interface, we prompt the user. In other interfaces, we default to
- # not adding the user, as the safest option.
- elsif (Bugzilla->usage_mode == USAGE_MODE_BROWSER) {
- # If we've already confirmed whether the user should be added...
- my $cgi = Bugzilla->cgi;
- my $add_confirmed = $cgi->param('confirm_add_duplicate');
- if (defined $add_confirmed) {
- $self->{_add_dup_cc} = $add_confirmed;
- }
- else {
- # Note that here we don't check if the user is already the reporter
- # of the dupe_of bug, since we already checked if they can *see*
- # the bug, above. People might have reporter_accessible turned
- # off, but cclist_accessible turned on, so they might want to
- # add the reporter even though they're already the reporter of the
- # dup_of bug.
- my $vars = {};
- my $template = Bugzilla->template;
- # Ask the user what they want to do about the reporter.
- $vars->{'cclist_accessible'} = $dupe_of_bug->cclist_accessible;
- $vars->{'original_bug_id'} = $dupe_of;
- $vars->{'duplicate_bug_id'} = $self->id;
- print $cgi->header();
- $template->process("bug/process/confirm-duplicate.html.tmpl", $vars)
- || ThrowTemplateError($template->error());
- exit;
- }
+ # Ask the user what they want to do about the reporter.
+ $vars->{'cclist_accessible'} = $dupe_of_bug->cclist_accessible;
+ $vars->{'original_bug_id'} = $dupe_of;
+ $vars->{'duplicate_bug_id'} = $self->id;
+ print $cgi->header();
+ $template->process("bug/process/confirm-duplicate.html.tmpl", $vars)
+ || ThrowTemplateError($template->error());
+ exit;
}
+ }
- return $dupe_of;
+ return $dupe_of;
}
sub _check_groups {
- my ($invocant, $group_names, undef, $params) = @_;
-
- my $bug_id = blessed($invocant) ? $invocant->id : undef;
- my $product = blessed($invocant) ? $invocant->product_obj
- : $params->{product};
- my %add_groups;
-
- # In email or WebServices, when the "groups" item actually
- # isn't specified, then just add the default groups.
- if (!defined $group_names) {
- my $available = $product->groups_available;
- foreach my $group (@$available) {
- $add_groups{$group->id} = $group if $group->{is_default};
- }
+ my ($invocant, $group_names, undef, $params) = @_;
+
+ my $bug_id = blessed($invocant) ? $invocant->id : undef;
+ my $product = blessed($invocant) ? $invocant->product_obj : $params->{product};
+ my %add_groups;
+
+ # In email or WebServices, when the "groups" item actually
+ # isn't specified, then just add the default groups.
+ if (!defined $group_names) {
+ my $available = $product->groups_available;
+ foreach my $group (@$available) {
+ $add_groups{$group->id} = $group if $group->{is_default};
}
- else {
- # Allow a comma-separated list, for email_in.pl.
- $group_names = [map { trim($_) } split(',', $group_names)]
- if !ref $group_names;
-
- # First check all the groups they chose to set.
- my %args = ( product => $product->name, bug_id => $bug_id, action => 'add' );
- foreach my $name (@$group_names) {
- my $group = Bugzilla::Group->check_no_disclose({ %args, name => $name });
-
- if (!$product->group_is_settable($group)) {
- ThrowUserError('group_restriction_not_allowed', { %args, name => $name });
- }
- $add_groups{$group->id} = $group;
- }
+ }
+ else {
+ # Allow a comma-separated list, for email_in.pl.
+ $group_names = [map { trim($_) } split(',', $group_names)] if !ref $group_names;
+
+ # First check all the groups they chose to set.
+ my %args = (product => $product->name, bug_id => $bug_id, action => 'add');
+ foreach my $name (@$group_names) {
+ my $group = Bugzilla::Group->check_no_disclose({%args, name => $name});
+
+ if (!$product->group_is_settable($group)) {
+ ThrowUserError('group_restriction_not_allowed', {%args, name => $name});
+ }
+ $add_groups{$group->id} = $group;
}
+ }
- # Now enforce mandatory groups.
- $add_groups{$_->id} = $_ foreach @{ $product->groups_mandatory };
+ # Now enforce mandatory groups.
+ $add_groups{$_->id} = $_ foreach @{$product->groups_mandatory};
- my @add_groups = values %add_groups;
- return \@add_groups;
+ my @add_groups = values %add_groups;
+ return \@add_groups;
}
sub _check_keywords {
- my ($invocant, $keywords_in, undef, $params) = @_;
+ my ($invocant, $keywords_in, undef, $params) = @_;
- return [] if !defined $keywords_in;
+ return [] if !defined $keywords_in;
- my $keyword_array = $keywords_in;
- if (!ref $keyword_array) {
- $keywords_in = trim($keywords_in);
- $keyword_array = [split(/[\s,]+/, $keywords_in)];
- }
-
- my %keywords;
- foreach my $keyword (@$keyword_array) {
- next unless $keyword;
- my $obj = Bugzilla::Keyword->check($keyword);
- $keywords{$obj->id} = $obj;
- }
- return [values %keywords];
+ my $keyword_array = $keywords_in;
+ if (!ref $keyword_array) {
+ $keywords_in = trim($keywords_in);
+ $keyword_array = [split(/[\s,]+/, $keywords_in)];
+ }
+
+ my %keywords;
+ foreach my $keyword (@$keyword_array) {
+ next unless $keyword;
+ my $obj = Bugzilla::Keyword->check($keyword);
+ $keywords{$obj->id} = $obj;
+ }
+ return [values %keywords];
}
sub _check_product {
- my ($invocant, $name) = @_;
- $name = trim($name);
- # If we're updating the bug and they haven't changed the product,
- # always allow it.
- if (ref $invocant && lc($invocant->product_obj->name) eq lc($name)) {
- return $invocant->product_obj;
- }
- # Check that the product exists and that the user
- # is allowed to enter bugs into this product.
- my $product = Bugzilla->user->can_enter_product($name, THROW_ERROR);
- return $product;
+ my ($invocant, $name) = @_;
+ $name = trim($name);
+
+ # If we're updating the bug and they haven't changed the product,
+ # always allow it.
+ if (ref $invocant && lc($invocant->product_obj->name) eq lc($name)) {
+ return $invocant->product_obj;
+ }
+
+ # Check that the product exists and that the user
+ # is allowed to enter bugs into this product.
+ my $product = Bugzilla->user->can_enter_product($name, THROW_ERROR);
+ return $product;
}
sub _check_priority {
- my ($invocant, $priority) = @_;
- if (!ref $invocant && !Bugzilla->params->{'letsubmitterchoosepriority'}) {
- $priority = Bugzilla->params->{'defaultpriority'};
- }
- return $invocant->_check_select_field($priority, 'priority');
+ my ($invocant, $priority) = @_;
+ if (!ref $invocant && !Bugzilla->params->{'letsubmitterchoosepriority'}) {
+ $priority = Bugzilla->params->{'defaultpriority'};
+ }
+ return $invocant->_check_select_field($priority, 'priority');
}
sub _check_qa_contact {
- my ($invocant, $qa_contact, undef, $params) = @_;
- $qa_contact = trim($qa_contact) if !ref $qa_contact;
- my $component = blessed($invocant) ? $invocant->component_obj
- : $params->{component};
- if (!ref $invocant) {
- # Bugs get no QA Contact on creation if useqacontact is off.
- return undef if !Bugzilla->params->{useqacontact};
- # Set the default QA Contact if one isn't specified or if the
- # user doesn't have editbugs.
- if (!Bugzilla->user->in_group('editbugs', $component->product_id)
- || !$qa_contact)
- {
- return $component->default_qa_contact ? $component->default_qa_contact->id : undef;
- }
+ my ($invocant, $qa_contact, undef, $params) = @_;
+ $qa_contact = trim($qa_contact) if !ref $qa_contact;
+ my $component
+ = blessed($invocant) ? $invocant->component_obj : $params->{component};
+ if (!ref $invocant) {
+
+ # Bugs get no QA Contact on creation if useqacontact is off.
+ return undef if !Bugzilla->params->{useqacontact};
+
+ # Set the default QA Contact if one isn't specified or if the
+ # user doesn't have editbugs.
+ if ( !Bugzilla->user->in_group('editbugs', $component->product_id)
+ || !$qa_contact)
+ {
+ return $component->default_qa_contact
+ ? $component->default_qa_contact->id
+ : undef;
}
+ }
- # If a QA Contact was specified or if we're updating, check
- # the QA Contact for validity.
- my $id;
- if ($qa_contact) {
- $qa_contact = Bugzilla::User->check($qa_contact) if !ref $qa_contact;
- $id = $qa_contact->id;
- # create() checks this another way, so we don't have to run this
- # check during create().
- # If there is no QA contact, this check is not required.
- $invocant->_check_strict_isolation_for_user($qa_contact)
- if (ref $invocant && $id);
- }
+ # If a QA Contact was specified or if we're updating, check
+ # the QA Contact for validity.
+ my $id;
+ if ($qa_contact) {
+ $qa_contact = Bugzilla::User->check($qa_contact) if !ref $qa_contact;
+ $id = $qa_contact->id;
+
+ # create() checks this another way, so we don't have to run this
+ # check during create().
+ # If there is no QA contact, this check is not required.
+ $invocant->_check_strict_isolation_for_user($qa_contact)
+ if (ref $invocant && $id);
+ }
- # "0" always means "undef", for QA Contact.
- return $id || undef;
+ # "0" always means "undef", for QA Contact.
+ return $id || undef;
}
sub _check_reporter {
- my $invocant = shift;
- my $reporter;
- if (ref $invocant) {
- # You cannot change the reporter of a bug.
- $reporter = $invocant->reporter->id;
- }
- else {
- # On bug creation, the reporter is the logged in user
- # (meaning that they must be logged in first!).
- Bugzilla->login(LOGIN_REQUIRED);
- $reporter = Bugzilla->user->id;
- }
- return $reporter;
+ my $invocant = shift;
+ my $reporter;
+ if (ref $invocant) {
+
+ # You cannot change the reporter of a bug.
+ $reporter = $invocant->reporter->id;
+ }
+ else {
+ # On bug creation, the reporter is the logged in user
+ # (meaning that they must be logged in first!).
+ Bugzilla->login(LOGIN_REQUIRED);
+ $reporter = Bugzilla->user->id;
+ }
+ return $reporter;
}
sub _check_resolution {
- my ($invocant, $resolution, undef, $params) = @_;
- $resolution = trim($resolution);
- my $status = ref($invocant) ? $invocant->status->name
- : $params->{bug_status};
- my $is_open = ref($invocant) ? $invocant->status->is_open
- : is_open_state($status);
-
- # Throw a special error for resolving bugs without a resolution
- # (or trying to change the resolution to '' on a closed bug without
- # using clear_resolution).
- ThrowUserError('missing_resolution', { status => $status })
- if !$resolution && !$is_open;
-
- # Make sure this is a valid resolution.
- $resolution = $invocant->_check_select_field($resolution, 'resolution');
-
- # Don't allow open bugs to have resolutions.
- ThrowUserError('resolution_not_allowed') if $is_open;
-
- # Check noresolveonopenblockers.
- my $dependson = ref($invocant) ? $invocant->dependson
- : ($params->{dependson} || []);
- if (Bugzilla->params->{"noresolveonopenblockers"}
- && $resolution eq 'FIXED'
- && (!ref $invocant or !$invocant->resolution
- or $resolution ne $invocant->resolution)
- && scalar @$dependson)
- {
- my $dep_bugs = Bugzilla::Bug->new_from_list($dependson);
- my $count_open = grep { $_->isopened } @$dep_bugs;
- if ($count_open) {
- my $bug_id = ref($invocant) ? $invocant->id : undef;
- ThrowUserError("still_unresolved_bugs",
- { bug_id => $bug_id, dep_count => $count_open });
- }
- }
-
- # Check if they're changing the resolution and need to comment.
- if (Bugzilla->params->{'commentonchange_resolution'}) {
- $invocant->_check_commenton($resolution, 'resolution', $params);
- }
-
- return $resolution;
+ my ($invocant, $resolution, undef, $params) = @_;
+ $resolution = trim($resolution);
+ my $status = ref($invocant) ? $invocant->status->name : $params->{bug_status};
+ my $is_open
+ = ref($invocant) ? $invocant->status->is_open : is_open_state($status);
+
+ # Throw a special error for resolving bugs without a resolution
+ # (or trying to change the resolution to '' on a closed bug without
+ # using clear_resolution).
+ ThrowUserError('missing_resolution', {status => $status})
+ if !$resolution && !$is_open;
+
+ # Make sure this is a valid resolution.
+ $resolution = $invocant->_check_select_field($resolution, 'resolution');
+
+ # Don't allow open bugs to have resolutions.
+ ThrowUserError('resolution_not_allowed') if $is_open;
+
+ # Check noresolveonopenblockers.
+ my $dependson
+ = ref($invocant) ? $invocant->dependson : ($params->{dependson} || []);
+ if (
+ Bugzilla->params->{"noresolveonopenblockers"}
+ && $resolution eq 'FIXED'
+ && ( !ref $invocant
+ or !$invocant->resolution
+ or $resolution ne $invocant->resolution)
+ && scalar @$dependson
+ )
+ {
+ my $dep_bugs = Bugzilla::Bug->new_from_list($dependson);
+ my $count_open = grep { $_->isopened } @$dep_bugs;
+ if ($count_open) {
+ my $bug_id = ref($invocant) ? $invocant->id : undef;
+ ThrowUserError("still_unresolved_bugs",
+ {bug_id => $bug_id, dep_count => $count_open});
+ }
+ }
+
+ # Check if they're changing the resolution and need to comment.
+ if (Bugzilla->params->{'commentonchange_resolution'}) {
+ $invocant->_check_commenton($resolution, 'resolution', $params);
+ }
+
+ return $resolution;
}
sub _check_short_desc {
- my ($invocant, $short_desc) = @_;
- # Set the parameter to itself, but cleaned up
- $short_desc = clean_text($short_desc) if $short_desc;
+ my ($invocant, $short_desc) = @_;
- if (!defined $short_desc || $short_desc eq '') {
- ThrowUserError("require_summary");
- }
- if (length($short_desc) > MAX_FREETEXT_LENGTH) {
- ThrowUserError('freetext_too_long',
- { field => 'short_desc', text => $short_desc });
- }
- return $short_desc;
+ # Set the parameter to itself, but cleaned up
+ $short_desc = clean_text($short_desc) if $short_desc;
+
+ if (!defined $short_desc || $short_desc eq '') {
+ ThrowUserError("require_summary");
+ }
+ if (length($short_desc) > MAX_FREETEXT_LENGTH) {
+ ThrowUserError('freetext_too_long',
+ {field => 'short_desc', text => $short_desc});
+ }
+ return $short_desc;
}
sub _check_status_whiteboard { return defined $_[1] ? $_[1] : ''; }
# Unlike other checkers, this one doesn't return anything.
sub _check_strict_isolation {
- my ($invocant, $ccs, $assignee, $qa_contact, $product) = @_;
- return unless Bugzilla->params->{'strict_isolation'};
-
- if (ref $invocant) {
- my $original = $invocant->new($invocant->id);
-
- # We only check people if they've been added. This way, if
- # strict_isolation is turned on when there are invalid users
- # on bugs, people can still add comments and so on.
- my @old_cc = map { $_->id } @{$original->cc_users};
- my @new_cc = map { $_->id } @{$invocant->cc_users};
- my ($removed, $added) = diff_arrays(\@old_cc, \@new_cc);
- $ccs = Bugzilla::User->new_from_list($added);
-
- $assignee = $invocant->assigned_to
- if $invocant->assigned_to->id != $original->assigned_to->id;
- if ($invocant->qa_contact
- && (!$original->qa_contact
- || $invocant->qa_contact->id != $original->qa_contact->id))
- {
- $qa_contact = $invocant->qa_contact;
- }
- $product = $invocant->product_obj;
+ my ($invocant, $ccs, $assignee, $qa_contact, $product) = @_;
+ return unless Bugzilla->params->{'strict_isolation'};
+
+ if (ref $invocant) {
+ my $original = $invocant->new($invocant->id);
+
+ # We only check people if they've been added. This way, if
+ # strict_isolation is turned on when there are invalid users
+ # on bugs, people can still add comments and so on.
+ my @old_cc = map { $_->id } @{$original->cc_users};
+ my @new_cc = map { $_->id } @{$invocant->cc_users};
+ my ($removed, $added) = diff_arrays(\@old_cc, \@new_cc);
+ $ccs = Bugzilla::User->new_from_list($added);
+
+ $assignee = $invocant->assigned_to
+ if $invocant->assigned_to->id != $original->assigned_to->id;
+ if (
+ $invocant->qa_contact
+ && (!$original->qa_contact
+ || $invocant->qa_contact->id != $original->qa_contact->id)
+ )
+ {
+ $qa_contact = $invocant->qa_contact;
}
+ $product = $invocant->product_obj;
+ }
- my @related_users = @$ccs;
- push(@related_users, $assignee) if $assignee;
+ my @related_users = @$ccs;
+ push(@related_users, $assignee) if $assignee;
- if (Bugzilla->params->{'useqacontact'} && $qa_contact) {
- push(@related_users, $qa_contact);
- }
+ if (Bugzilla->params->{'useqacontact'} && $qa_contact) {
+ push(@related_users, $qa_contact);
+ }
- @related_users = @{Bugzilla::User->new_from_list(\@related_users)}
- if !ref $invocant;
-
- # For each unique user in @related_users...(assignee and qa_contact
- # could be duplicates of users in the CC list)
- my %unique_users = map {$_->id => $_} @related_users;
- my @blocked_users;
- foreach my $id (keys %unique_users) {
- my $related_user = $unique_users{$id};
- if (!$related_user->can_edit_product($product->id) ||
- !$related_user->can_see_product($product->name)) {
- push (@blocked_users, $related_user->login);
- }
+ @related_users = @{Bugzilla::User->new_from_list(\@related_users)}
+ if !ref $invocant;
+
+ # For each unique user in @related_users...(assignee and qa_contact
+ # could be duplicates of users in the CC list)
+ my %unique_users = map { $_->id => $_ } @related_users;
+ my @blocked_users;
+ foreach my $id (keys %unique_users) {
+ my $related_user = $unique_users{$id};
+ if ( !$related_user->can_edit_product($product->id)
+ || !$related_user->can_see_product($product->name))
+ {
+ push(@blocked_users, $related_user->login);
}
- if (scalar(@blocked_users)) {
- my %vars = ( users => \@blocked_users,
- product => $product->name );
- if (ref $invocant) {
- $vars{'bug_id'} = $invocant->id;
- }
- else {
- $vars{'new'} = 1;
- }
- ThrowUserError("invalid_user_group", \%vars);
+ }
+ if (scalar(@blocked_users)) {
+ my %vars = (users => \@blocked_users, product => $product->name);
+ if (ref $invocant) {
+ $vars{'bug_id'} = $invocant->id;
}
+ else {
+ $vars{'new'} = 1;
+ }
+ ThrowUserError("invalid_user_group", \%vars);
+ }
}
# This is used by various set_ checkers, to make their code simpler.
sub _check_strict_isolation_for_user {
- my ($self, $user) = @_;
- return unless Bugzilla->params->{"strict_isolation"};
- if (!$user->can_edit_product($self->{product_id})) {
- ThrowUserError('invalid_user_group',
- { users => $user->login,
- product => $self->product,
- bug_id => $self->id });
- }
+ my ($self, $user) = @_;
+ return unless Bugzilla->params->{"strict_isolation"};
+ if (!$user->can_edit_product($self->{product_id})) {
+ ThrowUserError('invalid_user_group',
+ {users => $user->login, product => $self->product, bug_id => $self->id});
+ }
}
sub _check_tag_name {
- my ($invocant, $tag) = @_;
+ my ($invocant, $tag) = @_;
- $tag = clean_text($tag);
- $tag || ThrowUserError('no_tag_to_edit');
- ThrowUserError('tag_name_too_long') if length($tag) > MAX_LEN_QUERY_NAME;
- trick_taint($tag);
- # Tags are all lowercase.
- return lc($tag);
+ $tag = clean_text($tag);
+ $tag || ThrowUserError('no_tag_to_edit');
+ ThrowUserError('tag_name_too_long') if length($tag) > MAX_LEN_QUERY_NAME;
+ trick_taint($tag);
+
+ # Tags are all lowercase.
+ return lc($tag);
}
sub _check_target_milestone {
- my ($invocant, $target, undef, $params) = @_;
- my $product = blessed($invocant) ? $invocant->product_obj
- : $params->{product};
- my $old_target = blessed($invocant) ? $invocant->target_milestone : '';
- $target = trim($target);
- $target = $product->default_milestone if !defined $target;
- my $object = Bugzilla::Milestone->check(
- { product => $product, name => $target });
- if ($old_target && $object->name ne $old_target && !$object->is_active) {
- ThrowUserError('value_inactive', { class => ref($object), value => $target });
- }
- return $object->name;
+ my ($invocant, $target, undef, $params) = @_;
+ my $product = blessed($invocant) ? $invocant->product_obj : $params->{product};
+ my $old_target = blessed($invocant) ? $invocant->target_milestone : '';
+ $target = trim($target);
+ $target = $product->default_milestone if !defined $target;
+ my $object = Bugzilla::Milestone->check({product => $product, name => $target});
+ if ($old_target && $object->name ne $old_target && !$object->is_active) {
+ ThrowUserError('value_inactive', {class => ref($object), value => $target});
+ }
+ return $object->name;
}
sub _check_time_field {
- my ($invocant, $value, $field, $params) = @_;
+ my ($invocant, $value, $field, $params) = @_;
- # When filing bugs, we're forgiving and just return 0 if
- # the user isn't a timetracker. When updating bugs, check_can_change_field
- # controls permissions, so we don't want to check them here.
- if (!ref $invocant and !Bugzilla->user->is_timetracker) {
- return 0;
- }
+ # When filing bugs, we're forgiving and just return 0 if
+ # the user isn't a timetracker. When updating bugs, check_can_change_field
+ # controls permissions, so we don't want to check them here.
+ if (!ref $invocant and !Bugzilla->user->is_timetracker) {
+ return 0;
+ }
- # check_time is in Bugzilla::Object.
- return $invocant->check_time($value, $field, $params);
+ # check_time is in Bugzilla::Object.
+ return $invocant->check_time($value, $field, $params);
}
sub _check_version {
- my ($invocant, $version, undef, $params) = @_;
- $version = trim($version);
- my $product = blessed($invocant) ? $invocant->product_obj
- : $params->{product};
- my $old_vers = blessed($invocant) ? $invocant->version : '';
- my $object = Bugzilla::Version->check({ product => $product, name => $version });
- if ($object->name ne $old_vers && !$object->is_active) {
- ThrowUserError('value_inactive', { class => ref($object), value => $version });
- }
- return $object->name;
+ my ($invocant, $version, undef, $params) = @_;
+ $version = trim($version);
+ my $product = blessed($invocant) ? $invocant->product_obj : $params->{product};
+ my $old_vers = blessed($invocant) ? $invocant->version : '';
+ my $object = Bugzilla::Version->check({product => $product, name => $version});
+ if ($object->name ne $old_vers && !$object->is_active) {
+ ThrowUserError('value_inactive', {class => ref($object), value => $version});
+ }
+ return $object->name;
}
# Custom Field Validators
sub _check_field_is_mandatory {
- my ($invocant, $value, $field, $params) = @_;
+ my ($invocant, $value, $field, $params) = @_;
- if (!blessed($field)) {
- $field = Bugzilla::Field->new({ name => $field });
- return if !$field;
- }
+ if (!blessed($field)) {
+ $field = Bugzilla::Field->new({name => $field});
+ return if !$field;
+ }
- return if !$field->is_mandatory;
+ return if !$field->is_mandatory;
- return if !$field->is_visible_on_bug($params || $invocant);
+ return if !$field->is_visible_on_bug($params || $invocant);
- return if ($field->type == FIELD_TYPE_SINGLE_SELECT
- && scalar @{ get_legal_field_values($field->name) } == 1);
+ return
+ if ($field->type == FIELD_TYPE_SINGLE_SELECT
+ && scalar @{get_legal_field_values($field->name)} == 1);
- return if ($field->type == FIELD_TYPE_MULTI_SELECT
- && !scalar @{ get_legal_field_values($field->name) });
+ return
+ if ($field->type == FIELD_TYPE_MULTI_SELECT
+ && !scalar @{get_legal_field_values($field->name)});
- if (ref($value) eq 'ARRAY') {
- $value = join('', @$value);
- }
+ if (ref($value) eq 'ARRAY') {
+ $value = join('', @$value);
+ }
- $value = trim($value);
- if (!defined($value)
- or $value eq ""
- or ($value eq '---' and $field->type == FIELD_TYPE_SINGLE_SELECT)
- or ($value =~ EMPTY_DATETIME_REGEX
- and $field->type == FIELD_TYPE_DATETIME))
- {
- ThrowUserError('required_field', { field => $field });
- }
+ $value = trim($value);
+ if ( !defined($value)
+ or $value eq ""
+ or ($value eq '---' and $field->type == FIELD_TYPE_SINGLE_SELECT)
+ or ($value =~ EMPTY_DATETIME_REGEX and $field->type == FIELD_TYPE_DATETIME))
+ {
+ ThrowUserError('required_field', {field => $field});
+ }
}
sub _check_date_field {
- my ($invocant, $date) = @_;
- return $invocant->_check_datetime_field($date, undef, {date_only => 1});
+ my ($invocant, $date) = @_;
+ return $invocant->_check_datetime_field($date, undef, {date_only => 1});
}
sub _check_datetime_field {
- my ($invocant, $date_time, $field, $params) = @_;
-
- # Empty datetimes are empty strings or strings only containing
- # 0's, whitespace, and punctuation.
- if ($date_time =~ /^[\s0[:punct:]]*$/) {
- return undef;
- }
-
- $date_time = trim($date_time);
- my ($date, $time) = split(' ', $date_time);
- if ($date && !validate_date($date)) {
- ThrowUserError('illegal_date', { date => $date,
- format => 'YYYY-MM-DD' });
- }
- if ($time && $params->{date_only}) {
- ThrowUserError('illegal_date', { date => $date_time,
- format => 'YYYY-MM-DD' });
- }
- if ($time && !validate_time($time)) {
- ThrowUserError('illegal_time', { 'time' => $time,
- format => 'HH:MM:SS' });
- }
- return $date_time
+ my ($invocant, $date_time, $field, $params) = @_;
+
+ # Empty datetimes are empty strings or strings only containing
+ # 0's, whitespace, and punctuation.
+ if ($date_time =~ /^[\s0[:punct:]]*$/) {
+ return undef;
+ }
+
+ $date_time = trim($date_time);
+ my ($date, $time) = split(' ', $date_time);
+ if ($date && !validate_date($date)) {
+ ThrowUserError('illegal_date', {date => $date, format => 'YYYY-MM-DD'});
+ }
+ if ($time && $params->{date_only}) {
+ ThrowUserError('illegal_date', {date => $date_time, format => 'YYYY-MM-DD'});
+ }
+ if ($time && !validate_time($time)) {
+ ThrowUserError('illegal_time', {'time' => $time, format => 'HH:MM:SS'});
+ }
+ return $date_time;
}
sub _check_default_field { return defined $_[1] ? trim($_[1]) : ''; }
sub _check_freetext_field {
- my ($invocant, $text, $field) = @_;
+ my ($invocant, $text, $field) = @_;
- $text = (defined $text) ? trim($text) : '';
- if (length($text) > MAX_FREETEXT_LENGTH) {
- ThrowUserError('freetext_too_long',
- { field => $field, text => $text });
- }
- return $text;
+ $text = (defined $text) ? trim($text) : '';
+ if (length($text) > MAX_FREETEXT_LENGTH) {
+ ThrowUserError('freetext_too_long', {field => $field, text => $text});
+ }
+ return $text;
}
sub _check_multi_select_field {
- my ($invocant, $values, $field) = @_;
-
- # Allow users (mostly email_in.pl) to specify multi-selects as
- # comma-separated values.
- if (defined $values and !ref $values) {
- # We don't split on spaces because multi-select values can and often
- # do have spaces in them. (Theoretically they can have commas in them
- # too, but that's much less common and people should be able to work
- # around it pretty cleanly, if they want to use email_in.pl.)
- $values = [split(',', $values)];
- }
+ my ($invocant, $values, $field) = @_;
- return [] if !$values;
- my @checked_values;
- foreach my $value (@$values) {
- push(@checked_values, $invocant->_check_select_field($value, $field));
- }
- return \@checked_values;
+ # Allow users (mostly email_in.pl) to specify multi-selects as
+ # comma-separated values.
+ if (defined $values and !ref $values) {
+
+ # We don't split on spaces because multi-select values can and often
+ # do have spaces in them. (Theoretically they can have commas in them
+ # too, but that's much less common and people should be able to work
+ # around it pretty cleanly, if they want to use email_in.pl.)
+ $values = [split(',', $values)];
+ }
+
+ return [] if !$values;
+ my @checked_values;
+ foreach my $value (@$values) {
+ push(@checked_values, $invocant->_check_select_field($value, $field));
+ }
+ return \@checked_values;
}
sub _check_select_field {
- my ($invocant, $value, $field) = @_;
- my $object = Bugzilla::Field::Choice->type($field)->check($value);
- return $object->name;
+ my ($invocant, $value, $field) = @_;
+ my $object = Bugzilla::Field::Choice->type($field)->check($value);
+ return $object->name;
}
sub _check_bugid_field {
- my ($invocant, $value, $field) = @_;
- return undef if !$value;
-
- # check that the value is a valid, visible bug id
- my $checked_id = $invocant->check($value, $field)->id;
-
- # check for loop (can't have a loop if this is a new bug)
- if (ref $invocant) {
- _check_relationship_loop($field, $invocant->bug_id, $checked_id);
- }
+ my ($invocant, $value, $field) = @_;
+ return undef if !$value;
+
+ # check that the value is a valid, visible bug id
+ my $checked_id = $invocant->check($value, $field)->id;
+
+ # check for loop (can't have a loop if this is a new bug)
+ if (ref $invocant) {
+ _check_relationship_loop($field, $invocant->bug_id, $checked_id);
+ }
- return $checked_id;
+ return $checked_id;
}
sub _check_textarea_field {
- my ($invocant, $text, $field) = @_;
+ my ($invocant, $text, $field) = @_;
- $text = (defined $text) ? trim($text) : '';
+ $text = (defined $text) ? trim($text) : '';
- # Web browsers submit newlines as \r\n.
- # Sanitize all input to match the web standard.
- # XMLRPC input could be either \n or \r\n
- $text =~ s/\r?\n/\r\n/g;
+ # Web browsers submit newlines as \r\n.
+ # Sanitize all input to match the web standard.
+ # XMLRPC input could be either \n or \r\n
+ $text =~ s/\r?\n/\r\n/g;
- return $text;
+ return $text;
}
sub _check_integer_field {
- my ($invocant, $value, $field) = @_;
- $value = defined($value) ? trim($value) : '';
+ my ($invocant, $value, $field) = @_;
+ $value = defined($value) ? trim($value) : '';
- if ($value eq '') {
- return 0;
- }
+ if ($value eq '') {
+ return 0;
+ }
- my $orig_value = $value;
- if (!detaint_signed($value)) {
- ThrowUserError("number_not_integer",
- {field => $field, num => $orig_value});
- }
- elsif (abs($value) > MAX_INT_32) {
- ThrowUserError("number_too_large",
- {field => $field, num => $orig_value, max_num => MAX_INT_32});
- }
+ my $orig_value = $value;
+ if (!detaint_signed($value)) {
+ ThrowUserError("number_not_integer", {field => $field, num => $orig_value});
+ }
+ elsif (abs($value) > MAX_INT_32) {
+ ThrowUserError("number_too_large",
+ {field => $field, num => $orig_value, max_num => MAX_INT_32});
+ }
- return $value;
+ return $value;
}
sub _check_relationship_loop {
- # Generates a dependency tree for a given bug. Calls itself recursively
- # to generate sub-trees for the bug's dependencies.
- my ($field, $bug_id, $dep_id, $ids) = @_;
-
- # Don't do anything if this bug doesn't have any dependencies.
- return unless defined($dep_id);
-
- # Check whether we have seen this bug yet
- $ids = {} unless defined $ids;
- $ids->{$bug_id} = 1;
- if ($ids->{$dep_id}) {
- ThrowUserError("relationship_loop_single", {
- 'bug_id' => $bug_id,
- 'dep_id' => $dep_id,
- 'field_name' => $field});
- }
-
- # Get this dependency's record from the database
- my $dbh = Bugzilla->dbh;
- my $next_dep_id = $dbh->selectrow_array(
- "SELECT $field FROM bugs WHERE bug_id = ?", undef, $dep_id);
- _check_relationship_loop($field, $dep_id, $next_dep_id, $ids);
+ # Generates a dependency tree for a given bug. Calls itself recursively
+ # to generate sub-trees for the bug's dependencies.
+ my ($field, $bug_id, $dep_id, $ids) = @_;
+
+ # Don't do anything if this bug doesn't have any dependencies.
+ return unless defined($dep_id);
+
+ # Check whether we have seen this bug yet
+ $ids = {} unless defined $ids;
+ $ids->{$bug_id} = 1;
+ if ($ids->{$dep_id}) {
+ ThrowUserError("relationship_loop_single",
+ {'bug_id' => $bug_id, 'dep_id' => $dep_id, 'field_name' => $field});
+ }
+
+ # Get this dependency's record from the database
+ my $dbh = Bugzilla->dbh;
+ my $next_dep_id
+ = $dbh->selectrow_array("SELECT $field FROM bugs WHERE bug_id = ?",
+ undef, $dep_id);
+
+ _check_relationship_loop($field, $dep_id, $next_dep_id, $ids);
}
#####################################################################
@@ -2298,63 +2359,63 @@ sub _check_relationship_loop {
#####################################################################
sub fields {
- my $class = shift;
-
- my @fields =
- (
- # Standard Fields
- # Keep this ordering in sync with bugzilla.dtd.
- qw(bug_id alias creation_ts short_desc delta_ts
- reporter_accessible cclist_accessible
- classification_id classification
- product component version rep_platform op_sys
- bug_status resolution dup_id see_also
- bug_file_loc status_whiteboard keywords
- priority bug_severity target_milestone
- dependson blocked everconfirmed
- reporter assigned_to cc estimated_time
- remaining_time actual_time deadline),
-
- # Conditional Fields
- Bugzilla->params->{'useqacontact'} ? "qa_contact" : (),
- # Custom Fields
- map { $_->name } Bugzilla->active_custom_fields
- );
- Bugzilla::Hook::process('bug_fields', {'fields' => \@fields} );
-
- return @fields;
+ my $class = shift;
+
+ my @fields = (
+
+ # Standard Fields
+ # Keep this ordering in sync with bugzilla.dtd.
+ qw(bug_id alias creation_ts short_desc delta_ts
+ reporter_accessible cclist_accessible
+ classification_id classification
+ product component version rep_platform op_sys
+ bug_status resolution dup_id see_also
+ bug_file_loc status_whiteboard keywords
+ priority bug_severity target_milestone
+ dependson blocked everconfirmed
+ reporter assigned_to cc estimated_time
+ remaining_time actual_time deadline),
+
+ # Conditional Fields
+ Bugzilla->params->{'useqacontact'} ? "qa_contact" : (),
+
+ # Custom Fields
+ map { $_->name } Bugzilla->active_custom_fields
+ );
+ Bugzilla::Hook::process('bug_fields', {'fields' => \@fields});
+
+ return @fields;
}
#####################################################################
-# Mutators
+# Mutators
#####################################################################
# To run check_can_change_field.
sub _set_global_validator {
- my ($self, $value, $field) = @_;
- my $current = $self->$field;
- my $privs;
-
- if (ref $current && ref($current) ne 'ARRAY'
- && $current->isa('Bugzilla::Object')) {
- $current = $current->id ;
- }
- if (ref $value && ref($value) ne 'ARRAY'
- && $value->isa('Bugzilla::Object')) {
- $value = $value->id ;
- }
- my $can = $self->check_can_change_field($field, $current, $value, \$privs);
- if (!$can) {
- if ($field eq 'assigned_to' || $field eq 'qa_contact') {
- $value = Bugzilla::User->new($value)->login;
- $current = Bugzilla::User->new($current)->login;
- }
- ThrowUserError('illegal_change', { field => $field,
- oldvalue => $current,
- newvalue => $value,
- privs => $privs });
- }
- $self->_check_field_is_mandatory($value, $field);
+ my ($self, $value, $field) = @_;
+ my $current = $self->$field;
+ my $privs;
+
+ if ( ref $current
+ && ref($current) ne 'ARRAY'
+ && $current->isa('Bugzilla::Object'))
+ {
+ $current = $current->id;
+ }
+ if (ref $value && ref($value) ne 'ARRAY' && $value->isa('Bugzilla::Object')) {
+ $value = $value->id;
+ }
+ my $can = $self->check_can_change_field($field, $current, $value, \$privs);
+ if (!$can) {
+ if ($field eq 'assigned_to' || $field eq 'qa_contact') {
+ $value = Bugzilla::User->new($value)->login;
+ $current = Bugzilla::User->new($current)->login;
+ }
+ ThrowUserError('illegal_change',
+ {field => $field, oldvalue => $current, newvalue => $value, privs => $privs});
+ }
+ $self->_check_field_is_mandatory($value, $field);
}
@@ -2365,359 +2426,384 @@ sub _set_global_validator {
# Note that if you are changing multiple bugs at once, you must pass
# other_bugs to set_all in order for it to behave properly.
sub set_all {
- my $self = shift;
- my ($input_params) = @_;
-
- # Clone the data as we are going to alter it, and this would affect
- # subsequent bugs when calling set_all() again, as some fields would
- # be modified or no longer defined.
- my $params = {};
- %$params = %$input_params;
-
- # You cannot mark bugs as duplicate when changing several bugs at once
- # (because currently there is no way to check for duplicate loops in that
- # situation). You also cannot set the alias of several bugs at once.
- if ($params->{other_bugs} and scalar @{ $params->{other_bugs} } > 1) {
- ThrowUserError('dupe_not_allowed') if exists $params->{dup_id};
- ThrowUserError('multiple_alias_not_allowed')
- if defined $params->{alias};
- }
-
- # For security purposes, and because lots of other checks depend on it,
- # we set the product first before anything else.
- my $product_changed; # Used only for strict_isolation checks.
- if (exists $params->{'product'}) {
- $product_changed = $self->_set_product($params->{'product'}, $params);
- }
-
- # strict_isolation checks mean that we should set the groups
- # immediately after changing the product.
- $self->_add_remove($params, 'groups');
-
- if (exists $params->{'dependson'} or exists $params->{'blocked'}) {
- my %set_deps;
- foreach my $name (qw(dependson blocked)) {
- my @dep_ids = @{ $self->$name };
- # If only one of the two fields was passed in, then we need to
- # retain the current value for the other one.
- if (!exists $params->{$name}) {
- $set_deps{$name} = \@dep_ids;
- next;
- }
-
- # Explicitly setting them to a particular value overrides
- # add/remove.
- if (exists $params->{$name}->{set}) {
- $set_deps{$name} = $params->{$name}->{set};
- next;
- }
-
- foreach my $add (@{ $params->{$name}->{add} || [] }) {
- push(@dep_ids, $add) if !grep($_ == $add, @dep_ids);
- }
- foreach my $remove (@{ $params->{$name}->{remove} || [] }) {
- @dep_ids = grep($_ != $remove, @dep_ids);
- }
- $set_deps{$name} = \@dep_ids;
- }
-
- $self->set_dependencies($set_deps{'dependson'}, $set_deps{'blocked'});
- }
-
- if (exists $params->{'keywords'}) {
- # Sorting makes the order "add, remove, set", just like for other
- # fields.
- foreach my $action (sort keys %{ $params->{'keywords'} }) {
- $self->modify_keywords($params->{'keywords'}->{$action}, $action);
- }
- }
+ my $self = shift;
+ my ($input_params) = @_;
+
+ # Clone the data as we are going to alter it, and this would affect
+ # subsequent bugs when calling set_all() again, as some fields would
+ # be modified or no longer defined.
+ my $params = {};
+ %$params = %$input_params;
+
+ # You cannot mark bugs as duplicate when changing several bugs at once
+ # (because currently there is no way to check for duplicate loops in that
+ # situation). You also cannot set the alias of several bugs at once.
+ if ($params->{other_bugs} and scalar @{$params->{other_bugs}} > 1) {
+ ThrowUserError('dupe_not_allowed') if exists $params->{dup_id};
+ ThrowUserError('multiple_alias_not_allowed') if defined $params->{alias};
+ }
+
+ # For security purposes, and because lots of other checks depend on it,
+ # we set the product first before anything else.
+ my $product_changed; # Used only for strict_isolation checks.
+ if (exists $params->{'product'}) {
+ $product_changed = $self->_set_product($params->{'product'}, $params);
+ }
+
+ # strict_isolation checks mean that we should set the groups
+ # immediately after changing the product.
+ $self->_add_remove($params, 'groups');
+
+ if (exists $params->{'dependson'} or exists $params->{'blocked'}) {
+ my %set_deps;
+ foreach my $name (qw(dependson blocked)) {
+ my @dep_ids = @{$self->$name};
+
+ # If only one of the two fields was passed in, then we need to
+ # retain the current value for the other one.
+ if (!exists $params->{$name}) {
+ $set_deps{$name} = \@dep_ids;
+ next;
+ }
+
+ # Explicitly setting them to a particular value overrides
+ # add/remove.
+ if (exists $params->{$name}->{set}) {
+ $set_deps{$name} = $params->{$name}->{set};
+ next;
+ }
+
+ foreach my $add (@{$params->{$name}->{add} || []}) {
+ push(@dep_ids, $add) if !grep($_ == $add, @dep_ids);
+ }
+ foreach my $remove (@{$params->{$name}->{remove} || []}) {
+ @dep_ids = grep($_ != $remove, @dep_ids);
+ }
+ $set_deps{$name} = \@dep_ids;
+ }
+
+ $self->set_dependencies($set_deps{'dependson'}, $set_deps{'blocked'});
+ }
+
+ if (exists $params->{'keywords'}) {
+
+ # Sorting makes the order "add, remove, set", just like for other
+ # fields.
+ foreach my $action (sort keys %{$params->{'keywords'}}) {
+ $self->modify_keywords($params->{'keywords'}->{$action}, $action);
+ }
+ }
+
+ if (exists $params->{'comment'} or exists $params->{'work_time'}) {
+
+ # Add a comment as needed to each bug. This is done early because
+ # there are lots of things that want to check if we added a comment.
+ $self->add_comment(
+ $params->{'comment'}->{'body'},
+ {
+ isprivate => $params->{'comment'}->{'is_private'},
+ work_time => $params->{'work_time'}
+ }
+ );
+ }
- if (exists $params->{'comment'} or exists $params->{'work_time'}) {
- # Add a comment as needed to each bug. This is done early because
- # there are lots of things that want to check if we added a comment.
- $self->add_comment($params->{'comment'}->{'body'},
- { isprivate => $params->{'comment'}->{'is_private'},
- work_time => $params->{'work_time'} });
- }
+ if (exists $params->{alias} && $params->{alias}{set}) {
+ my ($removed_aliases, $added_aliases)
+ = diff_arrays($self->alias, $params->{alias}{set});
+ $params->{alias} = {add => $added_aliases, remove => $removed_aliases,};
+ }
- if (exists $params->{alias} && $params->{alias}{set}) {
- my ($removed_aliases, $added_aliases) = diff_arrays(
- $self->alias, $params->{alias}{set});
- $params->{alias} = {
- add => $added_aliases,
- remove => $removed_aliases,
- };
- }
+ my %normal_set_all;
+ foreach my $name (keys %$params) {
- my %normal_set_all;
- foreach my $name (keys %$params) {
- # These are handled separately below.
- if ($self->can("set_$name")) {
- $normal_set_all{$name} = $params->{$name};
- }
+ # These are handled separately below.
+ if ($self->can("set_$name")) {
+ $normal_set_all{$name} = $params->{$name};
}
- $self->SUPER::set_all(\%normal_set_all);
+ }
+ $self->SUPER::set_all(\%normal_set_all);
- $self->reset_assigned_to if $params->{'reset_assigned_to'};
- $self->reset_qa_contact if $params->{'reset_qa_contact'};
+ $self->reset_assigned_to if $params->{'reset_assigned_to'};
+ $self->reset_qa_contact if $params->{'reset_qa_contact'};
- $self->_add_remove($params, 'see_also');
+ $self->_add_remove($params, 'see_also');
- # And set custom fields.
- my @custom_fields = Bugzilla->active_custom_fields;
- foreach my $field (@custom_fields) {
- my $fname = $field->name;
- if (exists $params->{$fname}) {
- $self->set_custom_field($field, $params->{$fname});
- }
+ # And set custom fields.
+ my @custom_fields = Bugzilla->active_custom_fields;
+ foreach my $field (@custom_fields) {
+ my $fname = $field->name;
+ if (exists $params->{$fname}) {
+ $self->set_custom_field($field, $params->{$fname});
}
+ }
- $self->_add_remove($params, 'cc');
- $self->_add_remove($params, 'alias');
+ $self->_add_remove($params, 'cc');
+ $self->_add_remove($params, 'alias');
- # Theoretically you could move a product without ever specifying
- # a new assignee or qa_contact, or adding/removing any CCs. So,
- # we have to check that the current assignee, qa, and CCs are still
- # valid if we've switched products, under strict_isolation. We can only
- # do that here, because if they *did* change the assignee, qa, or CC,
- # then we don't want to check the original ones, only the new ones.
- $self->_check_strict_isolation() if $product_changed;
+ # Theoretically you could move a product without ever specifying
+ # a new assignee or qa_contact, or adding/removing any CCs. So,
+ # we have to check that the current assignee, qa, and CCs are still
+ # valid if we've switched products, under strict_isolation. We can only
+ # do that here, because if they *did* change the assignee, qa, or CC,
+ # then we don't want to check the original ones, only the new ones.
+ $self->_check_strict_isolation() if $product_changed;
}
# Helper for set_all that helps with fields that have an "add/remove"
# pattern instead of a "set_" pattern.
sub _add_remove {
- my ($self, $params, $name) = @_;
- my @add = @{ $params->{$name}->{add} || [] };
- my @remove = @{ $params->{$name}->{remove} || [] };
- $name =~ s/s$// if $name ne 'alias';
- my $add_method = "add_$name";
- my $remove_method = "remove_$name";
- $self->$add_method($_) foreach @add;
- $self->$remove_method($_) foreach @remove;
+ my ($self, $params, $name) = @_;
+ my @add = @{$params->{$name}->{add} || []};
+ my @remove = @{$params->{$name}->{remove} || []};
+ $name =~ s/s$// if $name ne 'alias';
+ my $add_method = "add_$name";
+ my $remove_method = "remove_$name";
+ $self->$add_method($_) foreach @add;
+ $self->$remove_method($_) foreach @remove;
}
sub set_assigned_to {
- my ($self, $value) = @_;
- $self->set('assigned_to', $value);
- # Store the old assignee. check_can_change_field() needs it.
- $self->{'_old_assigned_to'} = $self->{'assigned_to_obj'}->id;
- delete $self->{'assigned_to_obj'};
+ my ($self, $value) = @_;
+ $self->set('assigned_to', $value);
+
+ # Store the old assignee. check_can_change_field() needs it.
+ $self->{'_old_assigned_to'} = $self->{'assigned_to_obj'}->id;
+ delete $self->{'assigned_to_obj'};
}
+
sub reset_assigned_to {
- my $self = shift;
- my $comp = $self->component_obj;
- $self->set_assigned_to($comp->default_assignee);
+ my $self = shift;
+ my $comp = $self->component_obj;
+ $self->set_assigned_to($comp->default_assignee);
}
sub set_bug_ignored { $_[0]->set('bug_ignored', $_[1]); }
sub set_cclist_accessible { $_[0]->set('cclist_accessible', $_[1]); }
sub set_comment_is_private {
- my ($self, $comments, $isprivate) = @_;
- $self->{comment_isprivate} ||= [];
- my $is_insider = Bugzilla->user->is_insider;
+ my ($self, $comments, $isprivate) = @_;
+ $self->{comment_isprivate} ||= [];
+ my $is_insider = Bugzilla->user->is_insider;
- $comments = { $comments => $isprivate } unless ref $comments;
+ $comments = {$comments => $isprivate} unless ref $comments;
- foreach my $comment (@{$self->comments}) {
- # Skip unmodified comment privacy.
- next unless exists $comments->{$comment->id};
+ foreach my $comment (@{$self->comments}) {
- my $isprivate = delete $comments->{$comment->id} ? 1 : 0;
- if ($isprivate != $comment->is_private) {
- ThrowUserError('user_not_insider') unless $is_insider;
- $comment->set_is_private($isprivate);
- push @{$self->{comment_isprivate}}, $comment;
- }
+ # Skip unmodified comment privacy.
+ next unless exists $comments->{$comment->id};
+
+ my $isprivate = delete $comments->{$comment->id} ? 1 : 0;
+ if ($isprivate != $comment->is_private) {
+ ThrowUserError('user_not_insider') unless $is_insider;
+ $comment->set_is_private($isprivate);
+ push @{$self->{comment_isprivate}}, $comment;
}
+ }
- # If there are still entries in $comments, then they are illegal.
- ThrowUserError('comment_invalid_isprivate', { id => join(', ', keys %$comments) })
- if scalar keys %$comments;
-
- # If no comment privacy has been modified, remove this key.
- delete $self->{comment_isprivate} unless scalar @{$self->{comment_isprivate}};
-}
-
-sub set_component {
- my ($self, $name) = @_;
- my $old_comp = $self->component_obj;
- my $component = $self->_check_component($name);
- if ($old_comp->id != $component->id) {
- $self->{component_id} = $component->id;
- $self->{component} = $component->name;
- $self->{component_obj} = $component;
- # For update()
- $self->{_old_component_name} = $old_comp->name;
- # Add in the Default CC of the new Component;
- foreach my $cc (@{$component->initial_cc}) {
- $self->add_cc($cc);
- }
+ # If there are still entries in $comments, then they are illegal.
+ ThrowUserError('comment_invalid_isprivate', {id => join(', ', keys %$comments)})
+ if scalar keys %$comments;
+
+ # If no comment privacy has been modified, remove this key.
+ delete $self->{comment_isprivate} unless scalar @{$self->{comment_isprivate}};
+}
+
+sub set_component {
+ my ($self, $name) = @_;
+ my $old_comp = $self->component_obj;
+ my $component = $self->_check_component($name);
+ if ($old_comp->id != $component->id) {
+ $self->{component_id} = $component->id;
+ $self->{component} = $component->name;
+ $self->{component_obj} = $component;
+
+ # For update()
+ $self->{_old_component_name} = $old_comp->name;
+
+ # Add in the Default CC of the new Component;
+ foreach my $cc (@{$component->initial_cc}) {
+ $self->add_cc($cc);
}
+ }
}
+
sub set_custom_field {
- my ($self, $field, $value) = @_;
+ my ($self, $field, $value) = @_;
- if (ref $value eq 'ARRAY' && $field->type != FIELD_TYPE_MULTI_SELECT) {
- $value = $value->[0];
- }
- ThrowCodeError('field_not_custom', { field => $field }) if !$field->custom;
- $self->set($field->name, $value);
+ if (ref $value eq 'ARRAY' && $field->type != FIELD_TYPE_MULTI_SELECT) {
+ $value = $value->[0];
+ }
+ ThrowCodeError('field_not_custom', {field => $field}) if !$field->custom;
+ $self->set($field->name, $value);
}
sub set_deadline { $_[0]->set('deadline', $_[1]); }
+
sub set_dependencies {
- my ($self, $dependson, $blocked) = @_;
- my %extra = ( blocked => $blocked );
- $dependson = $self->_check_dependencies($dependson, 'dependson', \%extra);
- $blocked = $extra{blocked};
- # These may already be detainted, but all setters are supposed to
- # detaint their input if they've run a validator (just as though
- # we had used Bugzilla::Object::set), so we do that here.
- detaint_natural($_) foreach (@$dependson, @$blocked);
- $self->{'dependson'} = $dependson;
- $self->{'blocked'} = $blocked;
- delete $self->{depends_on_obj};
- delete $self->{blocks_obj};
+ my ($self, $dependson, $blocked) = @_;
+ my %extra = (blocked => $blocked);
+ $dependson = $self->_check_dependencies($dependson, 'dependson', \%extra);
+ $blocked = $extra{blocked};
+
+ # These may already be detainted, but all setters are supposed to
+ # detaint their input if they've run a validator (just as though
+ # we had used Bugzilla::Object::set), so we do that here.
+ detaint_natural($_) foreach (@$dependson, @$blocked);
+ $self->{'dependson'} = $dependson;
+ $self->{'blocked'} = $blocked;
+ delete $self->{depends_on_obj};
+ delete $self->{blocks_obj};
}
sub _clear_dup_id { $_[0]->{dup_id} = undef; }
+
sub set_dup_id {
- my ($self, $dup_id) = @_;
- my $old = $self->dup_id || 0;
- $self->set('dup_id', $dup_id);
- my $new = $self->dup_id;
- return if $old == $new;
-
- # Make sure that we have the DUPLICATE resolution. This is needed
- # if somebody calls set_dup_id without calling set_bug_status or
- # set_resolution.
- if ($self->resolution ne 'DUPLICATE') {
- # Even if the current status is VERIFIED, we change it back to
- # RESOLVED (or whatever the duplicate_or_move_bug_status is) here,
- # because that's the same thing the UI does when you click on the
- # "Mark as Duplicate" link. If people really want to retain their
- # current status, they can use set_bug_status and set the DUPLICATE
- # resolution before getting here.
- $self->set_bug_status(
- Bugzilla->params->{'duplicate_or_move_bug_status'},
- { resolution => 'DUPLICATE' });
- }
-
- # Update the other bug.
- my $dupe_of = new Bugzilla::Bug($self->dup_id);
- if (delete $self->{_add_dup_cc}) {
- $dupe_of->add_cc($self->reporter);
- }
- $dupe_of->add_comment("", { type => CMT_HAS_DUPE,
- extra_data => $self->id });
- $self->{_dup_for_update} = $dupe_of;
-
- # Now make sure that we add a duplicate comment on *this* bug.
- # (Change an existing comment into a dup comment, if there is one,
- # or add an empty dup comment.)
- if ($self->{added_comments}) {
- my @normal = grep { !defined $_->{type} || $_->{type} == CMT_NORMAL }
- @{ $self->{added_comments} };
- # Turn the last one into a dup comment.
- $normal[-1]->{type} = CMT_DUPE_OF;
- $normal[-1]->{extra_data} = $self->dup_id;
- }
- else {
- $self->add_comment('', { type => CMT_DUPE_OF,
- extra_data => $self->dup_id });
- }
+ my ($self, $dup_id) = @_;
+ my $old = $self->dup_id || 0;
+ $self->set('dup_id', $dup_id);
+ my $new = $self->dup_id;
+ return if $old == $new;
+
+ # Make sure that we have the DUPLICATE resolution. This is needed
+ # if somebody calls set_dup_id without calling set_bug_status or
+ # set_resolution.
+ if ($self->resolution ne 'DUPLICATE') {
+
+ # Even if the current status is VERIFIED, we change it back to
+ # RESOLVED (or whatever the duplicate_or_move_bug_status is) here,
+ # because that's the same thing the UI does when you click on the
+ # "Mark as Duplicate" link. If people really want to retain their
+ # current status, they can use set_bug_status and set the DUPLICATE
+ # resolution before getting here.
+ $self->set_bug_status(Bugzilla->params->{'duplicate_or_move_bug_status'},
+ {resolution => 'DUPLICATE'});
+ }
+
+ # Update the other bug.
+ my $dupe_of = new Bugzilla::Bug($self->dup_id);
+ if (delete $self->{_add_dup_cc}) {
+ $dupe_of->add_cc($self->reporter);
+ }
+ $dupe_of->add_comment("", {type => CMT_HAS_DUPE, extra_data => $self->id});
+ $self->{_dup_for_update} = $dupe_of;
+
+ # Now make sure that we add a duplicate comment on *this* bug.
+ # (Change an existing comment into a dup comment, if there is one,
+ # or add an empty dup comment.)
+ if ($self->{added_comments}) {
+ my @normal = grep { !defined $_->{type} || $_->{type} == CMT_NORMAL }
+ @{$self->{added_comments}};
+
+ # Turn the last one into a dup comment.
+ $normal[-1]->{type} = CMT_DUPE_OF;
+ $normal[-1]->{extra_data} = $self->dup_id;
+ }
+ else {
+ $self->add_comment('', {type => CMT_DUPE_OF, extra_data => $self->dup_id});
+ }
}
sub set_estimated_time { $_[0]->set('estimated_time', $_[1]); }
-sub _set_everconfirmed { $_[0]->set('everconfirmed', $_[1]); }
+sub _set_everconfirmed { $_[0]->set('everconfirmed', $_[1]); }
+
sub set_flags {
- my ($self, $flags, $new_flags) = @_;
+ my ($self, $flags, $new_flags) = @_;
- Bugzilla::Flag->set_flag($self, $_) foreach (@$flags, @$new_flags);
+ Bugzilla::Flag->set_flag($self, $_) foreach (@$flags, @$new_flags);
}
-sub set_op_sys { $_[0]->set('op_sys', $_[1]); }
-sub set_platform { $_[0]->set('rep_platform', $_[1]); }
-sub set_priority { $_[0]->set('priority', $_[1]); }
+sub set_op_sys { $_[0]->set('op_sys', $_[1]); }
+sub set_platform { $_[0]->set('rep_platform', $_[1]); }
+sub set_priority { $_[0]->set('priority', $_[1]); }
+
# For security reasons, you have to use set_all to change the product.
# See the strict_isolation check in set_all for an explanation.
sub _set_product {
- my ($self, $name, $params) = @_;
- my $old_product = $self->product_obj;
- my $product = $self->_check_product($name);
-
- my $product_changed = 0;
- if ($old_product->id != $product->id) {
- $self->{product_id} = $product->id;
- $self->{product} = $product->name;
- $self->{product_obj} = $product;
- # For update()
- $self->{_old_product_name} = $old_product->name;
- # Delete fields that depend upon the old Product value.
- delete $self->{choices};
- $product_changed = 1;
- }
+ my ($self, $name, $params) = @_;
+ my $old_product = $self->product_obj;
+ my $product = $self->_check_product($name);
- $params ||= {};
- # We delete these so that they're not set again later in set_all.
- my $comp_name = delete $params->{component} || $self->component;
- my $vers_name = delete $params->{version} || $self->version;
- my $tm_name = delete $params->{target_milestone};
- # This way, if usetargetmilestone is off and we've changed products,
- # set_target_milestone will reset our target_milestone to
- # $product->default_milestone. But if we haven't changed products,
- # we don't reset anything.
- if (!defined $tm_name
- && (Bugzilla->params->{'usetargetmilestone'} || !$product_changed))
- {
- $tm_name = $self->target_milestone;
- }
+ my $product_changed = 0;
+ if ($old_product->id != $product->id) {
+ $self->{product_id} = $product->id;
+ $self->{product} = $product->name;
+ $self->{product_obj} = $product;
- if ($product_changed && Bugzilla->usage_mode == USAGE_MODE_BROWSER) {
- # Try to set each value with the new product.
- # Have to set error_mode because Throw*Error calls exit() otherwise.
- my $old_error_mode = Bugzilla->error_mode;
- Bugzilla->error_mode(ERROR_MODE_DIE);
- my $component_ok = eval { $self->set_component($comp_name); 1; };
- my $version_ok = eval { $self->set_version($vers_name); 1; };
- my $milestone_ok = 1;
- # Reporters can move bugs between products but not set the TM.
- if ($self->check_can_change_field('target_milestone', 0, 1)) {
- $milestone_ok = eval { $self->set_target_milestone($tm_name); 1; };
- }
- else {
- # Have to set this directly to bypass the validators.
- $self->{target_milestone} = $product->default_milestone;
- }
- # If there were any errors thrown, make sure we don't mess up any
- # other part of Bugzilla that checks $@.
- undef $@;
- Bugzilla->error_mode($old_error_mode);
-
- my $verified = $params->{product_change_confirmed};
- my %vars;
- if (!$verified || !$component_ok || !$version_ok || !$milestone_ok) {
- $vars{defaults} = {
- # Note that because of the eval { set } above, these are
- # already set correctly if they're valid, otherwise they're
- # set to some invalid value which the template will ignore.
- component => $self->component,
- version => $self->version,
- milestone => $milestone_ok ? $self->target_milestone
- : $product->default_milestone
- };
- $vars{components} = [map { $_->name } grep($_->is_active, @{$product->components})];
- $vars{milestones} = [map { $_->name } grep($_->is_active, @{$product->milestones})];
- $vars{versions} = [map { $_->name } grep($_->is_active, @{$product->versions})];
- }
+ # For update()
+ $self->{_old_product_name} = $old_product->name;
- if (!$verified) {
- $vars{verify_bug_groups} = 1;
- my $dbh = Bugzilla->dbh;
- my @idlist = ($self->id);
- push(@idlist, map {$_->id} @{ $params->{other_bugs} })
- if $params->{other_bugs};
- @idlist = uniq @idlist;
- # Get the ID of groups which are no longer valid in the new product.
- my $gids = $dbh->selectcol_arrayref(
- 'SELECT bgm.group_id
+ # Delete fields that depend upon the old Product value.
+ delete $self->{choices};
+ $product_changed = 1;
+ }
+
+ $params ||= {};
+
+ # We delete these so that they're not set again later in set_all.
+ my $comp_name = delete $params->{component} || $self->component;
+ my $vers_name = delete $params->{version} || $self->version;
+ my $tm_name = delete $params->{target_milestone};
+
+ # This way, if usetargetmilestone is off and we've changed products,
+ # set_target_milestone will reset our target_milestone to
+ # $product->default_milestone. But if we haven't changed products,
+ # we don't reset anything.
+ if (!defined $tm_name
+ && (Bugzilla->params->{'usetargetmilestone'} || !$product_changed))
+ {
+ $tm_name = $self->target_milestone;
+ }
+
+ if ($product_changed && Bugzilla->usage_mode == USAGE_MODE_BROWSER) {
+
+ # Try to set each value with the new product.
+ # Have to set error_mode because Throw*Error calls exit() otherwise.
+ my $old_error_mode = Bugzilla->error_mode;
+ Bugzilla->error_mode(ERROR_MODE_DIE);
+ my $component_ok = eval { $self->set_component($comp_name); 1; };
+ my $version_ok = eval { $self->set_version($vers_name); 1; };
+ my $milestone_ok = 1;
+
+ # Reporters can move bugs between products but not set the TM.
+ if ($self->check_can_change_field('target_milestone', 0, 1)) {
+ $milestone_ok = eval { $self->set_target_milestone($tm_name); 1; };
+ }
+ else {
+ # Have to set this directly to bypass the validators.
+ $self->{target_milestone} = $product->default_milestone;
+ }
+
+ # If there were any errors thrown, make sure we don't mess up any
+ # other part of Bugzilla that checks $@.
+ undef $@;
+ Bugzilla->error_mode($old_error_mode);
+
+ my $verified = $params->{product_change_confirmed};
+ my %vars;
+ if (!$verified || !$component_ok || !$version_ok || !$milestone_ok) {
+ $vars{defaults} = {
+
+ # Note that because of the eval { set } above, these are
+ # already set correctly if they're valid, otherwise they're
+ # set to some invalid value which the template will ignore.
+ component => $self->component,
+ version => $self->version,
+ milestone => $milestone_ok
+ ? $self->target_milestone
+ : $product->default_milestone
+ };
+ $vars{components}
+ = [map { $_->name } grep($_->is_active, @{$product->components})];
+ $vars{milestones}
+ = [map { $_->name } grep($_->is_active, @{$product->milestones})];
+ $vars{versions} = [map { $_->name } grep($_->is_active, @{$product->versions})];
+ }
+
+ if (!$verified) {
+ $vars{verify_bug_groups} = 1;
+ my $dbh = Bugzilla->dbh;
+ my @idlist = ($self->id);
+ push(@idlist, map { $_->id } @{$params->{other_bugs}}) if $params->{other_bugs};
+ @idlist = uniq @idlist;
+
+ # Get the ID of groups which are no longer valid in the new product.
+ my $gids = $dbh->selectcol_arrayref(
+ 'SELECT bgm.group_id
FROM bug_group_map AS bgm
WHERE bgm.bug_id IN (' . join(',', ('?') x @idlist) . ')
AND bgm.group_id NOT IN
@@ -2726,159 +2812,172 @@ sub _set_product {
WHERE gcm.product_id = ?
AND ( (gcm.membercontrol != ?
AND gcm.group_id IN ('
- . Bugzilla->user->groups_as_string . '))
- OR gcm.othercontrol != ?) )',
- undef, (@idlist, $product->id, CONTROLMAPNA, CONTROLMAPNA));
- $vars{'old_groups'} = Bugzilla::Group->new_from_list($gids);
-
- # Did we come here from editing multiple bugs? (affects how we
- # show optional group changes)
- $vars{multiple_bugs} = (@idlist > 1) ? 1 : 0;
- }
-
- if (%vars) {
- $vars{product} = $product;
- $vars{bug} = $self;
- my $template = Bugzilla->template;
- $template->process("bug/process/verify-new-product.html.tmpl",
- \%vars) || ThrowTemplateError($template->error());
- exit;
- }
+ . Bugzilla->user->groups_as_string . '))
+ OR gcm.othercontrol != ?) )', undef,
+ (@idlist, $product->id, CONTROLMAPNA, CONTROLMAPNA)
+ );
+ $vars{'old_groups'} = Bugzilla::Group->new_from_list($gids);
+
+ # Did we come here from editing multiple bugs? (affects how we
+ # show optional group changes)
+ $vars{multiple_bugs} = (@idlist > 1) ? 1 : 0;
+ }
+
+ if (%vars) {
+ $vars{product} = $product;
+ $vars{bug} = $self;
+ my $template = Bugzilla->template;
+ $template->process("bug/process/verify-new-product.html.tmpl", \%vars)
+ || ThrowTemplateError($template->error());
+ exit;
+ }
+ }
+ else {
+ # When we're not in the browser (or we didn't change the product), we
+ # just die if any of these are invalid.
+ $self->set_component($comp_name);
+ $self->set_version($vers_name);
+ if ($product_changed
+ and !$self->check_can_change_field('target_milestone', 0, 1))
+ {
+ # Have to set this directly to bypass the validators.
+ $self->{target_milestone} = $product->default_milestone;
}
else {
- # When we're not in the browser (or we didn't change the product), we
- # just die if any of these are invalid.
- $self->set_component($comp_name);
- $self->set_version($vers_name);
- if ($product_changed
- and !$self->check_can_change_field('target_milestone', 0, 1))
- {
- # Have to set this directly to bypass the validators.
- $self->{target_milestone} = $product->default_milestone;
- }
- else {
- $self->set_target_milestone($tm_name);
- }
+ $self->set_target_milestone($tm_name);
}
+ }
- if ($product_changed) {
- # Remove groups that can't be set in the new product.
- # We copy this array because the original array is modified while we're
- # working, and that confuses "foreach".
- my @current_groups = @{$self->groups_in};
- foreach my $group (@current_groups) {
- if (!$product->group_is_valid($group)) {
- $self->remove_group($group);
- }
- }
+ if ($product_changed) {
- # Make sure the bug is in all the mandatory groups for the new product.
- foreach my $group (@{$product->groups_mandatory}) {
- $self->add_group($group);
- }
+ # Remove groups that can't be set in the new product.
+ # We copy this array because the original array is modified while we're
+ # working, and that confuses "foreach".
+ my @current_groups = @{$self->groups_in};
+ foreach my $group (@current_groups) {
+ if (!$product->group_is_valid($group)) {
+ $self->remove_group($group);
+ }
}
-
- return $product_changed;
+
+ # Make sure the bug is in all the mandatory groups for the new product.
+ foreach my $group (@{$product->groups_mandatory}) {
+ $self->add_group($group);
+ }
+ }
+
+ return $product_changed;
}
sub set_qa_contact {
- my ($self, $value) = @_;
- $self->set('qa_contact', $value);
- # Store the old QA contact. check_can_change_field() needs it.
- if ($self->{'qa_contact_obj'}) {
- $self->{'_old_qa_contact'} = $self->{'qa_contact_obj'}->id;
- }
- delete $self->{'qa_contact_obj'};
+ my ($self, $value) = @_;
+ $self->set('qa_contact', $value);
+
+ # Store the old QA contact. check_can_change_field() needs it.
+ if ($self->{'qa_contact_obj'}) {
+ $self->{'_old_qa_contact'} = $self->{'qa_contact_obj'}->id;
+ }
+ delete $self->{'qa_contact_obj'};
}
+
sub reset_qa_contact {
- my $self = shift;
- my $comp = $self->component_obj;
- $self->set_qa_contact($comp->default_qa_contact);
+ my $self = shift;
+ my $comp = $self->component_obj;
+ $self->set_qa_contact($comp->default_qa_contact);
}
sub set_remaining_time { $_[0]->set('remaining_time', $_[1]); }
+
# Used only when closing a bug or moving between closed states.
sub _zero_remaining_time { $_[0]->{'remaining_time'} = 0; }
sub set_reporter_accessible { $_[0]->set('reporter_accessible', $_[1]); }
+
sub set_resolution {
- my ($self, $value, $params) = @_;
-
- my $old_res = $self->resolution;
- $self->set('resolution', $value);
- delete $self->{choices};
- my $new_res = $self->resolution;
+ my ($self, $value, $params) = @_;
- if ($new_res ne $old_res) {
- # Clear the dup_id if we're leaving the dup resolution.
- if ($old_res eq 'DUPLICATE') {
- $self->_clear_dup_id();
- }
- # Duplicates should have no remaining time left.
- elsif ($new_res eq 'DUPLICATE' && $self->remaining_time != 0) {
- $self->_zero_remaining_time();
- }
+ my $old_res = $self->resolution;
+ $self->set('resolution', $value);
+ delete $self->{choices};
+ my $new_res = $self->resolution;
+
+ if ($new_res ne $old_res) {
+
+ # Clear the dup_id if we're leaving the dup resolution.
+ if ($old_res eq 'DUPLICATE') {
+ $self->_clear_dup_id();
}
-
- # We don't check if we're entering or leaving the dup resolution here,
- # because we could be moving from being a dup of one bug to being a dup
- # of another, theoretically. Note that this code block will also run
- # when going between different closed states.
- if ($self->resolution eq 'DUPLICATE') {
- if (my $dup_id = $params->{dup_id}) {
- $self->set_dup_id($dup_id);
- }
- elsif (!$self->dup_id) {
- ThrowUserError('dupe_id_required');
- }
+
+ # Duplicates should have no remaining time left.
+ elsif ($new_res eq 'DUPLICATE' && $self->remaining_time != 0) {
+ $self->_zero_remaining_time();
}
+ }
- # This method has handled dup_id, so set_all doesn't have to worry
- # about it now.
- delete $params->{dup_id};
+ # We don't check if we're entering or leaving the dup resolution here,
+ # because we could be moving from being a dup of one bug to being a dup
+ # of another, theoretically. Note that this code block will also run
+ # when going between different closed states.
+ if ($self->resolution eq 'DUPLICATE') {
+ if (my $dup_id = $params->{dup_id}) {
+ $self->set_dup_id($dup_id);
+ }
+ elsif (!$self->dup_id) {
+ ThrowUserError('dupe_id_required');
+ }
+ }
+
+ # This method has handled dup_id, so set_all doesn't have to worry
+ # about it now.
+ delete $params->{dup_id};
}
+
sub clear_resolution {
- my $self = shift;
- if (!$self->status->is_open) {
- ThrowUserError('resolution_cant_clear', { bug_id => $self->id });
- }
- $self->{'resolution'} = '';
- $self->_clear_dup_id;
+ my $self = shift;
+ if (!$self->status->is_open) {
+ ThrowUserError('resolution_cant_clear', {bug_id => $self->id});
+ }
+ $self->{'resolution'} = '';
+ $self->_clear_dup_id;
}
-sub set_severity { $_[0]->set('bug_severity', $_[1]); }
+sub set_severity { $_[0]->set('bug_severity', $_[1]); }
+
sub set_bug_status {
- my ($self, $status, $params) = @_;
- my $old_status = $self->status;
- $self->set('bug_status', $status);
- delete $self->{'status'};
- delete $self->{'statuses_available'};
- delete $self->{'choices'};
- my $new_status = $self->status;
-
- if ($new_status->is_open) {
- # Check for the everconfirmed transition
- $self->_set_everconfirmed($new_status->name eq 'UNCONFIRMED' ? 0 : 1);
- $self->clear_resolution();
- # Calling clear_resolution handled the "resolution" and "dup_id"
- # setting, so set_all doesn't have to worry about them.
- delete $params->{resolution};
- delete $params->{dup_id};
+ my ($self, $status, $params) = @_;
+ my $old_status = $self->status;
+ $self->set('bug_status', $status);
+ delete $self->{'status'};
+ delete $self->{'statuses_available'};
+ delete $self->{'choices'};
+ my $new_status = $self->status;
+
+ if ($new_status->is_open) {
+
+ # Check for the everconfirmed transition
+ $self->_set_everconfirmed($new_status->name eq 'UNCONFIRMED' ? 0 : 1);
+ $self->clear_resolution();
+
+ # Calling clear_resolution handled the "resolution" and "dup_id"
+ # setting, so set_all doesn't have to worry about them.
+ delete $params->{resolution};
+ delete $params->{dup_id};
+ }
+ else {
+ # We do this here so that we can make sure closed statuses have
+ # resolutions.
+ my $resolution = $self->resolution;
+
+ # We need to check "defined" to prevent people from passing
+ # a blank resolution in the WebService, which would otherwise fail
+ # silently.
+ if (defined $params->{resolution}) {
+ $resolution = delete $params->{resolution};
}
- else {
- # We do this here so that we can make sure closed statuses have
- # resolutions.
- my $resolution = $self->resolution;
- # We need to check "defined" to prevent people from passing
- # a blank resolution in the WebService, which would otherwise fail
- # silently.
- if (defined $params->{resolution}) {
- $resolution = delete $params->{resolution};
- }
- $self->set_resolution($resolution, $params);
+ $self->set_resolution($resolution, $params);
- # Changing between closed statuses zeros the remaining time.
- if ($new_status->id != $old_status->id && $self->remaining_time != 0) {
- $self->_zero_remaining_time();
- }
+ # Changing between closed statuses zeros the remaining time.
+ if ($new_status->id != $old_status->id && $self->remaining_time != 0) {
+ $self->_zero_remaining_time();
}
+ }
}
sub set_status_whiteboard { $_[0]->set('status_whiteboard', $_[1]); }
sub set_summary { $_[0]->set('short_desc', $_[1]); }
@@ -2895,373 +2994,390 @@ sub set_version { $_[0]->set('version', $_[1]); }
# Accepts a User object or a username. Adds the user only if they
# don't already exist as a CC on the bug.
sub add_cc {
- my ($self, $user_or_name) = @_;
- return if !$user_or_name;
- my $user = ref $user_or_name ? $user_or_name
- : Bugzilla::User->check($user_or_name);
- $self->_check_strict_isolation_for_user($user);
- my $cc_users = $self->cc_users;
- push(@$cc_users, $user) if !grep($_->id == $user->id, @$cc_users);
+ my ($self, $user_or_name) = @_;
+ return if !$user_or_name;
+ my $user
+ = ref $user_or_name ? $user_or_name : Bugzilla::User->check($user_or_name);
+ $self->_check_strict_isolation_for_user($user);
+ my $cc_users = $self->cc_users;
+ push(@$cc_users, $user) if !grep($_->id == $user->id, @$cc_users);
}
# Accepts a User object or a username. Removes the User if they exist
# in the list, but doesn't throw an error if they don't exist.
sub remove_cc {
- my ($self, $user_or_name) = @_;
- my $user = ref $user_or_name ? $user_or_name
- : Bugzilla::User->check($user_or_name);
- my $currentUser = Bugzilla->user;
- if (!$self->user->{'canedit'} && $user->id != $currentUser->id) {
- ThrowUserError('cc_remove_denied');
- }
- my $cc_users = $self->cc_users;
- @$cc_users = grep { $_->id != $user->id } @$cc_users;
+ my ($self, $user_or_name) = @_;
+ my $user
+ = ref $user_or_name ? $user_or_name : Bugzilla::User->check($user_or_name);
+ my $currentUser = Bugzilla->user;
+ if (!$self->user->{'canedit'} && $user->id != $currentUser->id) {
+ ThrowUserError('cc_remove_denied');
+ }
+ my $cc_users = $self->cc_users;
+ @$cc_users = grep { $_->id != $user->id } @$cc_users;
}
sub add_alias {
- my ($self, $alias) = @_;
- return if !$alias;
- my $aliases = $self->_check_alias($alias);
- $alias = $aliases->[0];
- my @new_aliases;
- my $found = 0;
- foreach my $old_alias (@{ $self->alias }) {
- if (lc($old_alias) eq lc($alias)) {
- push(@new_aliases, $alias);
- $found = 1;
- }
- else {
- push(@new_aliases, $old_alias);
- }
+ my ($self, $alias) = @_;
+ return if !$alias;
+ my $aliases = $self->_check_alias($alias);
+ $alias = $aliases->[0];
+ my @new_aliases;
+ my $found = 0;
+ foreach my $old_alias (@{$self->alias}) {
+ if (lc($old_alias) eq lc($alias)) {
+ push(@new_aliases, $alias);
+ $found = 1;
+ }
+ else {
+ push(@new_aliases, $old_alias);
}
- push(@new_aliases, $alias) if !$found;
- $self->{alias} = \@new_aliases;
+ }
+ push(@new_aliases, $alias) if !$found;
+ $self->{alias} = \@new_aliases;
}
sub remove_alias {
- my ($self, $alias) = @_;
- my $bug_aliases = $self->alias;
- @$bug_aliases = grep { $_ ne $alias } @$bug_aliases;
+ my ($self, $alias) = @_;
+ my $bug_aliases = $self->alias;
+ @$bug_aliases = grep { $_ ne $alias } @$bug_aliases;
}
# $bug->add_comment("comment", {isprivate => 1, work_time => 10.5,
# type => CMT_NORMAL, extra_data => $data});
sub add_comment {
- my ($self, $comment, $params) = @_;
+ my ($self, $comment, $params) = @_;
- $params ||= {};
+ $params ||= {};
- # Fill out info that doesn't change and callers may not pass in
- $params->{'bug_id'} = $self;
- $params->{'thetext'} = defined($comment) ? $comment : '';
+ # Fill out info that doesn't change and callers may not pass in
+ $params->{'bug_id'} = $self;
+ $params->{'thetext'} = defined($comment) ? $comment : '';
- # Validate all the entered data
- Bugzilla::Comment->check_required_create_fields($params);
- $params = Bugzilla::Comment->run_create_validators($params);
+ # Validate all the entered data
+ Bugzilla::Comment->check_required_create_fields($params);
+ $params = Bugzilla::Comment->run_create_validators($params);
- # This makes it so we won't create new comments when there is nothing
- # to add
- if ($params->{'thetext'} eq ''
- && !($params->{type} || abs($params->{work_time} || 0)))
- {
- return;
- }
+ # This makes it so we won't create new comments when there is nothing
+ # to add
+ if ($params->{'thetext'} eq ''
+ && !($params->{type} || abs($params->{work_time} || 0)))
+ {
+ return;
+ }
- # If the user has explicitly set remaining_time, this will be overridden
- # later in set_all. But if they haven't, this keeps remaining_time
- # up-to-date.
- if ($params->{work_time}) {
- $self->set_remaining_time(max($self->remaining_time - $params->{work_time}, 0));
- }
+ # If the user has explicitly set remaining_time, this will be overridden
+ # later in set_all. But if they haven't, this keeps remaining_time
+ # up-to-date.
+ if ($params->{work_time}) {
+ $self->set_remaining_time(max($self->remaining_time - $params->{work_time}, 0));
+ }
- $self->{added_comments} ||= [];
+ $self->{added_comments} ||= [];
- push(@{$self->{added_comments}}, $params);
+ push(@{$self->{added_comments}}, $params);
}
sub modify_keywords {
- my ($self, $keywords, $action) = @_;
+ my ($self, $keywords, $action) = @_;
- if (!$action || !grep { $action eq $_ } qw(add remove set)) {
- $action = 'set';
- }
+ if (!$action || !grep { $action eq $_ } qw(add remove set)) {
+ $action = 'set';
+ }
- $keywords = $self->_check_keywords($keywords);
- my @old_keywords = @{ $self->keyword_objects };
- my @result;
+ $keywords = $self->_check_keywords($keywords);
+ my @old_keywords = @{$self->keyword_objects};
+ my @result;
- if ($action eq 'set') {
- @result = @$keywords;
+ if ($action eq 'set') {
+ @result = @$keywords;
+ }
+ else {
+ # We're adding or deleting specific keywords.
+ my %keys = map { $_->id => $_ } @old_keywords;
+ if ($action eq 'add') {
+ $keys{$_->id} = $_ foreach @$keywords;
}
else {
- # We're adding or deleting specific keywords.
- my %keys = map { $_->id => $_ } @old_keywords;
- if ($action eq 'add') {
- $keys{$_->id} = $_ foreach @$keywords;
- }
- else {
- delete $keys{$_->id} foreach @$keywords;
- }
- @result = values %keys;
+ delete $keys{$_->id} foreach @$keywords;
}
+ @result = values %keys;
+ }
- # Check if anything was added or removed.
- my @old_ids = map { $_->id } @old_keywords;
- my @new_ids = map { $_->id } @result;
- my ($removed, $added) = diff_arrays(\@old_ids, \@new_ids);
- my $any_changes = scalar @$removed || scalar @$added;
+ # Check if anything was added or removed.
+ my @old_ids = map { $_->id } @old_keywords;
+ my @new_ids = map { $_->id } @result;
+ my ($removed, $added) = diff_arrays(\@old_ids, \@new_ids);
+ my $any_changes = scalar @$removed || scalar @$added;
- # Make sure we retain the sort order.
- @result = sort {lc($a->name) cmp lc($b->name)} @result;
+ # Make sure we retain the sort order.
+ @result = sort { lc($a->name) cmp lc($b->name) } @result;
- if ($any_changes) {
- my $privs;
- my $new = join(', ', (map {$_->name} @result));
- my $check = $self->check_can_change_field('keywords', 0, 1, \$privs)
- || ThrowUserError('illegal_change', { field => 'keywords',
- oldvalue => $self->keywords,
- newvalue => $new,
- privs => $privs });
- }
-
- $self->{'keyword_objects'} = \@result;
+ if ($any_changes) {
+ my $privs;
+ my $new = join(', ', (map { $_->name } @result));
+ my $check
+ = $self->check_can_change_field('keywords', 0, 1, \$privs) || ThrowUserError(
+ 'illegal_change',
+ {
+ field => 'keywords',
+ oldvalue => $self->keywords,
+ newvalue => $new,
+ privs => $privs
+ }
+ );
+ }
+
+ $self->{'keyword_objects'} = \@result;
}
sub add_group {
- my ($self, $group) = @_;
+ my ($self, $group) = @_;
- # If the user enters "FoO" but the DB has "Foo", $group->name would
- # return "Foo" and thus revealing the existence of the group name.
- # So we have to store and pass the name as entered by the user to
- # the error message, if we have it.
- my $group_name = blessed($group) ? $group->name : $group;
- my $args = { name => $group_name, product => $self->product,
- bug_id => $self->id, action => 'add' };
+ # If the user enters "FoO" but the DB has "Foo", $group->name would
+ # return "Foo" and thus revealing the existence of the group name.
+ # So we have to store and pass the name as entered by the user to
+ # the error message, if we have it.
+ my $group_name = blessed($group) ? $group->name : $group;
+ my $args = {
+ name => $group_name,
+ product => $self->product,
+ bug_id => $self->id,
+ action => 'add'
+ };
- $group = Bugzilla::Group->check_no_disclose($args) if !blessed $group;
+ $group = Bugzilla::Group->check_no_disclose($args) if !blessed $group;
- # If the bug is already in this group, then there is nothing to do.
- return if $self->in_group($group);
+ # If the bug is already in this group, then there is nothing to do.
+ return if $self->in_group($group);
- # Make sure that bugs in this product can actually be restricted
- # to this group by the current user.
- $self->product_obj->group_is_settable($group)
- || ThrowUserError('group_restriction_not_allowed', $args);
+ # Make sure that bugs in this product can actually be restricted
+ # to this group by the current user.
+ $self->product_obj->group_is_settable($group)
+ || ThrowUserError('group_restriction_not_allowed', $args);
- # OtherControl people can add groups only during a product change,
- # and only when the group is not NA for them.
- if (!Bugzilla->user->in_group($group->name)) {
- my $controls = $self->product_obj->group_controls->{$group->id};
- if (!$self->{_old_product_name}
- || $controls->{othercontrol} == CONTROLMAPNA)
- {
- ThrowUserError('group_restriction_not_allowed', $args);
- }
+ # OtherControl people can add groups only during a product change,
+ # and only when the group is not NA for them.
+ if (!Bugzilla->user->in_group($group->name)) {
+ my $controls = $self->product_obj->group_controls->{$group->id};
+ if (!$self->{_old_product_name} || $controls->{othercontrol} == CONTROLMAPNA) {
+ ThrowUserError('group_restriction_not_allowed', $args);
}
+ }
- my $current_groups = $self->groups_in;
- push(@$current_groups, $group);
+ my $current_groups = $self->groups_in;
+ push(@$current_groups, $group);
}
sub remove_group {
- my ($self, $group) = @_;
+ my ($self, $group) = @_;
- # See add_group() for the reason why we store the user input.
- my $group_name = blessed($group) ? $group->name : $group;
- my $args = { name => $group_name, product => $self->product,
- bug_id => $self->id, action => 'remove' };
+ # See add_group() for the reason why we store the user input.
+ my $group_name = blessed($group) ? $group->name : $group;
+ my $args = {
+ name => $group_name,
+ product => $self->product,
+ bug_id => $self->id,
+ action => 'remove'
+ };
- $group = Bugzilla::Group->check_no_disclose($args) if !blessed $group;
+ $group = Bugzilla::Group->check_no_disclose($args) if !blessed $group;
- # If the bug isn't in this group, then either the name is misspelled,
- # or the group really doesn't exist. Let the user know about this problem.
- $self->in_group($group) || ThrowUserError('group_invalid_removal', $args);
+ # If the bug isn't in this group, then either the name is misspelled,
+ # or the group really doesn't exist. Let the user know about this problem.
+ $self->in_group($group) || ThrowUserError('group_invalid_removal', $args);
- # Check if this is a valid group for this product. You can *always*
- # remove a group that is not valid for this product (set_product does this).
- # This particularly happens when we're moving a bug to a new product.
- # You still have to be a member of an inactive group to remove it.
- if ($self->product_obj->group_is_valid($group)) {
- my $controls = $self->product_obj->group_controls->{$group->id};
+ # Check if this is a valid group for this product. You can *always*
+ # remove a group that is not valid for this product (set_product does this).
+ # This particularly happens when we're moving a bug to a new product.
+ # You still have to be a member of an inactive group to remove it.
+ if ($self->product_obj->group_is_valid($group)) {
+ my $controls = $self->product_obj->group_controls->{$group->id};
- # Nobody can ever remove a Mandatory group, unless it became inactive.
- if ($controls->{membercontrol} == CONTROLMAPMANDATORY && $group->is_active) {
- ThrowUserError('group_invalid_removal', $args);
- }
+ # Nobody can ever remove a Mandatory group, unless it became inactive.
+ if ($controls->{membercontrol} == CONTROLMAPMANDATORY && $group->is_active) {
+ ThrowUserError('group_invalid_removal', $args);
+ }
- # OtherControl people can remove groups only during a product change,
- # and only when they are non-Mandatory and non-NA.
- if (!Bugzilla->user->in_group($group->name)) {
- if (!$self->{_old_product_name}
- || $controls->{othercontrol} == CONTROLMAPMANDATORY
- || $controls->{othercontrol} == CONTROLMAPNA)
- {
- ThrowUserError('group_invalid_removal', $args);
- }
- }
+ # OtherControl people can remove groups only during a product change,
+ # and only when they are non-Mandatory and non-NA.
+ if (!Bugzilla->user->in_group($group->name)) {
+ if (!$self->{_old_product_name}
+ || $controls->{othercontrol} == CONTROLMAPMANDATORY
+ || $controls->{othercontrol} == CONTROLMAPNA)
+ {
+ ThrowUserError('group_invalid_removal', $args);
+ }
}
+ }
- my $current_groups = $self->groups_in;
- @$current_groups = grep { $_->id != $group->id } @$current_groups;
+ my $current_groups = $self->groups_in;
+ @$current_groups = grep { $_->id != $group->id } @$current_groups;
}
sub add_see_also {
- my ($self, $input, $skip_recursion) = @_;
+ my ($self, $input, $skip_recursion) = @_;
- # This is needed by xt/search.t.
- $input = $input->name if blessed($input);
+ # This is needed by xt/search.t.
+ $input = $input->name if blessed($input);
- $input = trim($input);
- return if !$input;
+ $input = trim($input);
+ return if !$input;
- my ($class, $uri) = Bugzilla::BugUrl->class_for($input);
+ my ($class, $uri) = Bugzilla::BugUrl->class_for($input);
- my $params = { value => $uri, bug_id => $self, class => $class };
- $class->check_required_create_fields($params);
+ my $params = {value => $uri, bug_id => $self, class => $class};
+ $class->check_required_create_fields($params);
- my $field_values = $class->run_create_validators($params);
- my $value = $field_values->{value}->as_string;
- trick_taint($value);
- $field_values->{value} = $value;
-
- # We only add the new URI if it hasn't been added yet. URIs are
- # case-sensitive, but most of our DBs are case-insensitive, so we do
- # this check case-insensitively.
- if (!grep { lc($_->name) eq lc($value) } @{ $self->see_also }) {
- my $privs;
- my $can = $self->check_can_change_field('see_also', '', $value, \$privs);
- if (!$can) {
- ThrowUserError('illegal_change', { field => 'see_also',
- newvalue => $value,
- privs => $privs });
- }
- # If this is a link to a local bug then save the
- # ref bug id for sending changes email.
- my $ref_bug = delete $field_values->{ref_bug};
- if ($class->isa('Bugzilla::BugUrl::Bugzilla::Local')
- and !$skip_recursion
- and $ref_bug->check_can_change_field('see_also', '', $self->id, \$privs))
- {
- $ref_bug->add_see_also($self->id, 'skip_recursion');
- push @{ $self->{_update_ref_bugs} }, $ref_bug;
- push @{ $self->{see_also_changes} }, $ref_bug->id;
- }
- push @{ $self->{see_also} }, bless ($field_values, $class);
- }
-}
-
-sub remove_see_also {
- my ($self, $url, $skip_recursion) = @_;
- my $see_also = $self->see_also;
-
- # This is needed by xt/search.t.
- $url = $url->name if blessed($url);
-
- my ($removed_bug_url, $new_see_also) =
- part { lc($_->name) ne lc($url) } @$see_also;
+ my $field_values = $class->run_create_validators($params);
+ my $value = $field_values->{value}->as_string;
+ trick_taint($value);
+ $field_values->{value} = $value;
+ # We only add the new URI if it hasn't been added yet. URIs are
+ # case-sensitive, but most of our DBs are case-insensitive, so we do
+ # this check case-insensitively.
+ if (!grep { lc($_->name) eq lc($value) } @{$self->see_also}) {
my $privs;
- my $can = $self->check_can_change_field('see_also', $see_also, $new_see_also, \$privs);
+ my $can = $self->check_can_change_field('see_also', '', $value, \$privs);
if (!$can) {
- ThrowUserError('illegal_change', { field => 'see_also',
- oldvalue => $url,
- privs => $privs });
+ ThrowUserError('illegal_change',
+ {field => 'see_also', newvalue => $value, privs => $privs});
}
- # Since we remove also the url from the referenced bug,
- # we need to notify changes for that bug too.
- $removed_bug_url = $removed_bug_url->[0];
- if (!$skip_recursion and $removed_bug_url
- and $removed_bug_url->isa('Bugzilla::BugUrl::Bugzilla::Local')
- and $removed_bug_url->ref_bug_url)
+ # If this is a link to a local bug then save the
+ # ref bug id for sending changes email.
+ my $ref_bug = delete $field_values->{ref_bug};
+ if ( $class->isa('Bugzilla::BugUrl::Bugzilla::Local')
+ and !$skip_recursion
+ and $ref_bug->check_can_change_field('see_also', '', $self->id, \$privs))
{
- my $ref_bug
- = Bugzilla::Bug->check($removed_bug_url->ref_bug_url->bug_id);
+ $ref_bug->add_see_also($self->id, 'skip_recursion');
+ push @{$self->{_update_ref_bugs}}, $ref_bug;
+ push @{$self->{see_also_changes}}, $ref_bug->id;
+ }
+ push @{$self->{see_also}}, bless($field_values, $class);
+ }
+}
- if (Bugzilla->user->can_edit_product($ref_bug->product_id)
- and $ref_bug->check_can_change_field('see_also', $self->id, '', \$privs))
- {
- my $self_url = $removed_bug_url->local_uri($self->id);
- $ref_bug->remove_see_also($self_url, 'skip_recursion');
- push @{ $self->{_update_ref_bugs} }, $ref_bug;
- push @{ $self->{see_also_changes} }, $ref_bug->id;
- }
+sub remove_see_also {
+ my ($self, $url, $skip_recursion) = @_;
+ my $see_also = $self->see_also;
+
+ # This is needed by xt/search.t.
+ $url = $url->name if blessed($url);
+
+ my ($removed_bug_url, $new_see_also)
+ = part { lc($_->name) ne lc($url) } @$see_also;
+
+ my $privs;
+ my $can = $self->check_can_change_field('see_also', $see_also, $new_see_also,
+ \$privs);
+ if (!$can) {
+ ThrowUserError('illegal_change',
+ {field => 'see_also', oldvalue => $url, privs => $privs});
+ }
+
+ # Since we remove also the url from the referenced bug,
+ # we need to notify changes for that bug too.
+ $removed_bug_url = $removed_bug_url->[0];
+ if ( !$skip_recursion
+ and $removed_bug_url
+ and $removed_bug_url->isa('Bugzilla::BugUrl::Bugzilla::Local')
+ and $removed_bug_url->ref_bug_url)
+ {
+ my $ref_bug = Bugzilla::Bug->check($removed_bug_url->ref_bug_url->bug_id);
+
+ if (Bugzilla->user->can_edit_product($ref_bug->product_id)
+ and $ref_bug->check_can_change_field('see_also', $self->id, '', \$privs))
+ {
+ my $self_url = $removed_bug_url->local_uri($self->id);
+ $ref_bug->remove_see_also($self_url, 'skip_recursion');
+ push @{$self->{_update_ref_bugs}}, $ref_bug;
+ push @{$self->{see_also_changes}}, $ref_bug->id;
}
+ }
- $self->{see_also} = $new_see_also || [];
+ $self->{see_also} = $new_see_also || [];
}
sub add_tag {
- my ($self, $tag) = @_;
- my $dbh = Bugzilla->dbh;
- my $user = Bugzilla->user;
- $tag = $self->_check_tag_name($tag);
-
- my $tag_id = $user->tags->{$tag}->{id};
- # If this tag doesn't exist for this user yet, create it.
- if (!$tag_id) {
- $dbh->do('INSERT INTO tag (user_id, name) VALUES (?, ?)',
- undef, ($user->id, $tag));
-
- $tag_id = $dbh->selectrow_array('SELECT id FROM tag
- WHERE name = ? AND user_id = ?',
- undef, ($tag, $user->id));
- # The list has changed.
- delete $user->{tags};
- }
- # Do nothing if this tag is already set for this bug.
- return if grep { $_ eq $tag } @{$self->tags};
+ my ($self, $tag) = @_;
+ my $dbh = Bugzilla->dbh;
+ my $user = Bugzilla->user;
+ $tag = $self->_check_tag_name($tag);
+
+ my $tag_id = $user->tags->{$tag}->{id};
+
+ # If this tag doesn't exist for this user yet, create it.
+ if (!$tag_id) {
+ $dbh->do('INSERT INTO tag (user_id, name) VALUES (?, ?)',
+ undef, ($user->id, $tag));
+
+ $tag_id = $dbh->selectrow_array(
+ 'SELECT id FROM tag
+ WHERE name = ? AND user_id = ?', undef,
+ ($tag, $user->id)
+ );
- # Increment the counter. Do it before the SQL call below,
- # to not count the tag twice.
- $user->tags->{$tag}->{bug_count}++;
+ # The list has changed.
+ delete $user->{tags};
+ }
- $dbh->do('INSERT INTO bug_tag (bug_id, tag_id) VALUES (?, ?)',
- undef, ($self->id, $tag_id));
+ # Do nothing if this tag is already set for this bug.
+ return if grep { $_ eq $tag } @{$self->tags};
- push(@{$self->{tags}}, $tag);
+ # Increment the counter. Do it before the SQL call below,
+ # to not count the tag twice.
+ $user->tags->{$tag}->{bug_count}++;
+
+ $dbh->do('INSERT INTO bug_tag (bug_id, tag_id) VALUES (?, ?)',
+ undef, ($self->id, $tag_id));
+
+ push(@{$self->{tags}}, $tag);
}
sub remove_tag {
- my ($self, $tag) = @_;
- my $dbh = Bugzilla->dbh;
- my $user = Bugzilla->user;
- $tag = $self->_check_tag_name($tag);
+ my ($self, $tag) = @_;
+ my $dbh = Bugzilla->dbh;
+ my $user = Bugzilla->user;
+ $tag = $self->_check_tag_name($tag);
- my $tag_id = exists $user->tags->{$tag} ? $user->tags->{$tag}->{id} : undef;
- # Do nothing if the user doesn't use this tag, or didn't set it for this bug.
- return unless ($tag_id && grep { $_ eq $tag } @{$self->tags});
+ my $tag_id = exists $user->tags->{$tag} ? $user->tags->{$tag}->{id} : undef;
- $dbh->do('DELETE FROM bug_tag WHERE bug_id = ? AND tag_id = ?',
- undef, ($self->id, $tag_id));
+ # Do nothing if the user doesn't use this tag, or didn't set it for this bug.
+ return unless ($tag_id && grep { $_ eq $tag } @{$self->tags});
- $self->{tags} = [grep { $_ ne $tag } @{$self->tags}];
+ $dbh->do('DELETE FROM bug_tag WHERE bug_id = ? AND tag_id = ?',
+ undef, ($self->id, $tag_id));
- # Decrement the counter, and delete the tag if no bugs are using it anymore.
- if (!--$user->tags->{$tag}->{bug_count}) {
- $dbh->do('DELETE FROM tag WHERE name = ? AND user_id = ?',
- undef, ($tag, $user->id));
+ $self->{tags} = [grep { $_ ne $tag } @{$self->tags}];
- # The list has changed.
- delete $user->{tags};
- }
+ # Decrement the counter, and delete the tag if no bugs are using it anymore.
+ if (!--$user->tags->{$tag}->{bug_count}) {
+ $dbh->do('DELETE FROM tag WHERE name = ? AND user_id = ?',
+ undef, ($tag, $user->id));
+
+ # The list has changed.
+ delete $user->{tags};
+ }
}
sub tags {
- my $self = shift;
- my $dbh = Bugzilla->dbh;
- my $user = Bugzilla->user;
-
- # This method doesn't support several users using the same bug object.
- if (!exists $self->{tags}) {
- $self->{tags} = $dbh->selectcol_arrayref(
- 'SELECT name FROM bug_tag
+ my $self = shift;
+ my $dbh = Bugzilla->dbh;
+ my $user = Bugzilla->user;
+
+ # This method doesn't support several users using the same bug object.
+ if (!exists $self->{tags}) {
+ $self->{tags} = $dbh->selectcol_arrayref(
+ 'SELECT name FROM bug_tag
INNER JOIN tag ON tag.id = bug_tag.tag_id
- WHERE bug_id = ? AND user_id = ?',
- undef, ($self->id, $user->id));
- }
- return $self->{tags};
+ WHERE bug_id = ? AND user_id = ?', undef, ($self->id, $user->id)
+ );
+ }
+ return $self->{tags};
}
#####################################################################
@@ -3271,30 +3387,30 @@ sub tags {
# These are accessors that don't need to access the database.
# Keep them in alphabetical order.
-sub bug_file_loc { return $_[0]->{bug_file_loc} }
-sub bug_id { return $_[0]->{bug_id} }
-sub bug_severity { return $_[0]->{bug_severity} }
-sub bug_status { return $_[0]->{bug_status} }
-sub cclist_accessible { return $_[0]->{cclist_accessible} }
-sub component_id { return $_[0]->{component_id} }
-sub creation_ts { return $_[0]->{creation_ts} }
-sub estimated_time { return $_[0]->{estimated_time} }
-sub deadline { return $_[0]->{deadline} }
-sub delta_ts { return $_[0]->{delta_ts} }
-sub error { return $_[0]->{error} }
-sub everconfirmed { return $_[0]->{everconfirmed} }
-sub lastdiffed { return $_[0]->{lastdiffed} }
-sub op_sys { return $_[0]->{op_sys} }
-sub priority { return $_[0]->{priority} }
-sub product_id { return $_[0]->{product_id} }
-sub remaining_time { return $_[0]->{remaining_time} }
+sub bug_file_loc { return $_[0]->{bug_file_loc} }
+sub bug_id { return $_[0]->{bug_id} }
+sub bug_severity { return $_[0]->{bug_severity} }
+sub bug_status { return $_[0]->{bug_status} }
+sub cclist_accessible { return $_[0]->{cclist_accessible} }
+sub component_id { return $_[0]->{component_id} }
+sub creation_ts { return $_[0]->{creation_ts} }
+sub estimated_time { return $_[0]->{estimated_time} }
+sub deadline { return $_[0]->{deadline} }
+sub delta_ts { return $_[0]->{delta_ts} }
+sub error { return $_[0]->{error} }
+sub everconfirmed { return $_[0]->{everconfirmed} }
+sub lastdiffed { return $_[0]->{lastdiffed} }
+sub op_sys { return $_[0]->{op_sys} }
+sub priority { return $_[0]->{priority} }
+sub product_id { return $_[0]->{product_id} }
+sub remaining_time { return $_[0]->{remaining_time} }
sub reporter_accessible { return $_[0]->{reporter_accessible} }
-sub rep_platform { return $_[0]->{rep_platform} }
-sub resolution { return $_[0]->{resolution} }
-sub short_desc { return $_[0]->{short_desc} }
-sub status_whiteboard { return $_[0]->{status_whiteboard} }
-sub target_milestone { return $_[0]->{target_milestone} }
-sub version { return $_[0]->{version} }
+sub rep_platform { return $_[0]->{rep_platform} }
+sub resolution { return $_[0]->{resolution} }
+sub short_desc { return $_[0]->{short_desc} }
+sub status_whiteboard { return $_[0]->{status_whiteboard} }
+sub target_milestone { return $_[0]->{target_milestone} }
+sub version { return $_[0]->{version} }
#####################################################################
# Complex Accessors
@@ -3313,674 +3429,713 @@ sub version { return $_[0]->{version} }
# security holes.
sub dup_id {
- my ($self) = @_;
- return $self->{'dup_id'} if exists $self->{'dup_id'};
+ my ($self) = @_;
+ return $self->{'dup_id'} if exists $self->{'dup_id'};
- $self->{'dup_id'} = undef;
- return if $self->{'error'};
+ $self->{'dup_id'} = undef;
+ return if $self->{'error'};
- if ($self->{'resolution'} eq 'DUPLICATE') {
- my $dbh = Bugzilla->dbh;
- $self->{'dup_id'} =
- $dbh->selectrow_array(q{SELECT dupe_of
+ if ($self->{'resolution'} eq 'DUPLICATE') {
+ my $dbh = Bugzilla->dbh;
+ $self->{'dup_id'} = $dbh->selectrow_array(
+ q{SELECT dupe_of
FROM duplicates
- WHERE dupe = ?},
- undef,
- $self->{'bug_id'});
- }
- return $self->{'dup_id'};
+ WHERE dupe = ?}, undef, $self->{'bug_id'}
+ );
+ }
+ return $self->{'dup_id'};
}
sub _resolve_ultimate_dup_id {
- my ($bug_id, $dupe_of, $loops_are_an_error) = @_;
- my $dbh = Bugzilla->dbh;
- my $sth = $dbh->prepare('SELECT dupe_of FROM duplicates WHERE dupe = ?');
-
- my $this_dup = $dupe_of || $dbh->selectrow_array($sth, undef, $bug_id);
- my $last_dup = $bug_id;
-
- my %dupes;
- while ($this_dup) {
- if ($this_dup == $bug_id) {
- if ($loops_are_an_error) {
- ThrowUserError('dupe_loop_detected', { bug_id => $bug_id,
- dupe_of => $dupe_of });
- }
- else {
- return $last_dup;
- }
- }
- # If $dupes{$this_dup} is already set to 1, then a loop
- # already exists which does not involve this bug.
- # As the user is not responsible for this loop, do not
- # prevent them from marking this bug as a duplicate.
- return $last_dup if exists $dupes{$this_dup};
- $dupes{$this_dup} = 1;
- $last_dup = $this_dup;
- $this_dup = $dbh->selectrow_array($sth, undef, $this_dup);
+ my ($bug_id, $dupe_of, $loops_are_an_error) = @_;
+ my $dbh = Bugzilla->dbh;
+ my $sth = $dbh->prepare('SELECT dupe_of FROM duplicates WHERE dupe = ?');
+
+ my $this_dup = $dupe_of || $dbh->selectrow_array($sth, undef, $bug_id);
+ my $last_dup = $bug_id;
+
+ my %dupes;
+ while ($this_dup) {
+ if ($this_dup == $bug_id) {
+ if ($loops_are_an_error) {
+ ThrowUserError('dupe_loop_detected', {bug_id => $bug_id, dupe_of => $dupe_of});
+ }
+ else {
+ return $last_dup;
+ }
}
- return $last_dup;
+ # If $dupes{$this_dup} is already set to 1, then a loop
+ # already exists which does not involve this bug.
+ # As the user is not responsible for this loop, do not
+ # prevent them from marking this bug as a duplicate.
+ return $last_dup if exists $dupes{$this_dup};
+ $dupes{$this_dup} = 1;
+ $last_dup = $this_dup;
+ $this_dup = $dbh->selectrow_array($sth, undef, $this_dup);
+ }
+
+ return $last_dup;
}
sub actual_time {
- my ($self) = @_;
- return $self->{'actual_time'} if exists $self->{'actual_time'};
+ my ($self) = @_;
+ return $self->{'actual_time'} if exists $self->{'actual_time'};
- if ( $self->{'error'} || !Bugzilla->user->is_timetracker ) {
- $self->{'actual_time'} = undef;
- return $self->{'actual_time'};
- }
+ if ($self->{'error'} || !Bugzilla->user->is_timetracker) {
+ $self->{'actual_time'} = undef;
+ return $self->{'actual_time'};
+ }
- my $sth = Bugzilla->dbh->prepare("SELECT SUM(work_time)
+ my $sth = Bugzilla->dbh->prepare(
+ "SELECT SUM(work_time)
FROM longdescs
- WHERE longdescs.bug_id=?");
- $sth->execute($self->{bug_id});
- $self->{'actual_time'} = $sth->fetchrow_array();
- return $self->{'actual_time'};
+ WHERE longdescs.bug_id=?"
+ );
+ $sth->execute($self->{bug_id});
+ $self->{'actual_time'} = $sth->fetchrow_array();
+ return $self->{'actual_time'};
}
sub alias {
- my ($self) = @_;
- return $self->{'alias'} if exists $self->{'alias'};
- return [] if $self->{'error'};
+ my ($self) = @_;
+ return $self->{'alias'} if exists $self->{'alias'};
+ return [] if $self->{'error'};
- my $dbh = Bugzilla->dbh;
- $self->{'alias'} = $dbh->selectcol_arrayref(
- q{SELECT alias FROM bugs_aliases WHERE bug_id = ? ORDER BY alias},
- undef, $self->bug_id);
+ my $dbh = Bugzilla->dbh;
+ $self->{'alias'}
+ = $dbh->selectcol_arrayref(
+ q{SELECT alias FROM bugs_aliases WHERE bug_id = ? ORDER BY alias},
+ undef, $self->bug_id);
- return $self->{'alias'};
+ return $self->{'alias'};
}
sub any_flags_requesteeble {
- my ($self) = @_;
- return $self->{'any_flags_requesteeble'}
- if exists $self->{'any_flags_requesteeble'};
- return 0 if $self->{'error'};
+ my ($self) = @_;
+ return $self->{'any_flags_requesteeble'}
+ if exists $self->{'any_flags_requesteeble'};
+ return 0 if $self->{'error'};
- my $any_flags_requesteeble =
- grep { $_->is_requestable && $_->is_requesteeble } @{$self->flag_types};
- # Useful in case a flagtype is no longer requestable but a requestee
- # has been set before we turned off that bit.
- $any_flags_requesteeble ||= grep { $_->requestee_id } @{$self->flags};
- $self->{'any_flags_requesteeble'} = $any_flags_requesteeble;
+ my $any_flags_requesteeble
+ = grep { $_->is_requestable && $_->is_requesteeble } @{$self->flag_types};
- return $self->{'any_flags_requesteeble'};
+ # Useful in case a flagtype is no longer requestable but a requestee
+ # has been set before we turned off that bit.
+ $any_flags_requesteeble ||= grep { $_->requestee_id } @{$self->flags};
+ $self->{'any_flags_requesteeble'} = $any_flags_requesteeble;
+
+ return $self->{'any_flags_requesteeble'};
}
sub attachments {
- my ($self) = @_;
- return $self->{'attachments'} if exists $self->{'attachments'};
- return [] if $self->{'error'};
+ my ($self) = @_;
+ return $self->{'attachments'} if exists $self->{'attachments'};
+ return [] if $self->{'error'};
- $self->{'attachments'} =
- Bugzilla::Attachment->get_attachments_by_bug($self, {preload => 1});
- $_->object_cache_set() foreach @{ $self->{'attachments'} };
- return $self->{'attachments'};
+ $self->{'attachments'}
+ = Bugzilla::Attachment->get_attachments_by_bug($self, {preload => 1});
+ $_->object_cache_set() foreach @{$self->{'attachments'}};
+ return $self->{'attachments'};
}
sub assigned_to {
- my ($self) = @_;
- return $self->{'assigned_to_obj'} if exists $self->{'assigned_to_obj'};
- $self->{'assigned_to'} = 0 if $self->{'error'};
- $self->{'assigned_to_obj'} ||= new Bugzilla::User({ id => $self->{'assigned_to'}, cache => 1 });
- return $self->{'assigned_to_obj'};
+ my ($self) = @_;
+ return $self->{'assigned_to_obj'} if exists $self->{'assigned_to_obj'};
+ $self->{'assigned_to'} = 0 if $self->{'error'};
+ $self->{'assigned_to_obj'}
+ ||= new Bugzilla::User({id => $self->{'assigned_to'}, cache => 1});
+ return $self->{'assigned_to_obj'};
}
sub blocked {
- my ($self) = @_;
- return $self->{'blocked'} if exists $self->{'blocked'};
- return [] if $self->{'error'};
- $self->{'blocked'} = EmitDependList("dependson", "blocked", $self->bug_id);
- return $self->{'blocked'};
+ my ($self) = @_;
+ return $self->{'blocked'} if exists $self->{'blocked'};
+ return [] if $self->{'error'};
+ $self->{'blocked'} = EmitDependList("dependson", "blocked", $self->bug_id);
+ return $self->{'blocked'};
}
sub blocks_obj {
- my ($self) = @_;
- $self->{blocks_obj} ||= $self->_bugs_in_order($self->blocked);
- return $self->{blocks_obj};
+ my ($self) = @_;
+ $self->{blocks_obj} ||= $self->_bugs_in_order($self->blocked);
+ return $self->{blocks_obj};
}
sub bug_group {
- my ($self) = @_;
- return join(', ', (map { $_->name } @{$self->groups_in}));
+ my ($self) = @_;
+ return join(', ', (map { $_->name } @{$self->groups_in}));
}
sub related_bugs {
- my ($self, $relationship) = @_;
- return [] if $self->{'error'};
+ my ($self, $relationship) = @_;
+ return [] if $self->{'error'};
- my $field_name = $relationship->name;
- $self->{'related_bugs'}->{$field_name} ||= $self->match({$field_name => $self->id});
- return $self->{'related_bugs'}->{$field_name};
+ my $field_name = $relationship->name;
+ $self->{'related_bugs'}->{$field_name}
+ ||= $self->match({$field_name => $self->id});
+ return $self->{'related_bugs'}->{$field_name};
}
sub cc {
- my ($self) = @_;
- return $self->{'cc'} if exists $self->{'cc'};
- return [] if $self->{'error'};
+ my ($self) = @_;
+ return $self->{'cc'} if exists $self->{'cc'};
+ return [] if $self->{'error'};
- my $dbh = Bugzilla->dbh;
- $self->{'cc'} = $dbh->selectcol_arrayref(
- q{SELECT profiles.login_name FROM cc, profiles
+ my $dbh = Bugzilla->dbh;
+ $self->{'cc'} = $dbh->selectcol_arrayref(
+ q{SELECT profiles.login_name FROM cc, profiles
WHERE bug_id = ?
AND cc.who = profiles.userid
- ORDER BY profiles.login_name},
- undef, $self->bug_id);
+ ORDER BY profiles.login_name}, undef, $self->bug_id
+ );
- return $self->{'cc'};
+ return $self->{'cc'};
}
# XXX Eventually this will become the standard "cc" method used everywhere.
sub cc_users {
- my $self = shift;
- return $self->{'cc_users'} if exists $self->{'cc_users'};
- return [] if $self->{'error'};
-
- my $dbh = Bugzilla->dbh;
- my $cc_ids = $dbh->selectcol_arrayref(
- 'SELECT who FROM cc WHERE bug_id = ?', undef, $self->id);
- $self->{'cc_users'} = Bugzilla::User->new_from_list($cc_ids);
- return $self->{'cc_users'};
+ my $self = shift;
+ return $self->{'cc_users'} if exists $self->{'cc_users'};
+ return [] if $self->{'error'};
+
+ my $dbh = Bugzilla->dbh;
+ my $cc_ids = $dbh->selectcol_arrayref('SELECT who FROM cc WHERE bug_id = ?',
+ undef, $self->id);
+ $self->{'cc_users'} = Bugzilla::User->new_from_list($cc_ids);
+ return $self->{'cc_users'};
}
sub component {
- my ($self) = @_;
- return '' if $self->{error};
- $self->{component} //= $self->component_obj->name;
- return $self->{component};
+ my ($self) = @_;
+ return '' if $self->{error};
+ $self->{component} //= $self->component_obj->name;
+ return $self->{component};
}
# XXX Eventually this will replace component()
sub component_obj {
- my ($self) = @_;
- return $self->{component_obj} if defined $self->{component_obj};
- return {} if $self->{error};
- $self->{component_obj} =
- new Bugzilla::Component({ id => $self->{component_id}, cache => 1 });
- return $self->{component_obj};
+ my ($self) = @_;
+ return $self->{component_obj} if defined $self->{component_obj};
+ return {} if $self->{error};
+ $self->{component_obj}
+ = new Bugzilla::Component({id => $self->{component_id}, cache => 1});
+ return $self->{component_obj};
}
sub classification_id {
- my ($self) = @_;
- return 0 if $self->{error};
- $self->{classification_id} //= $self->product_obj->classification_id;
- return $self->{classification_id};
+ my ($self) = @_;
+ return 0 if $self->{error};
+ $self->{classification_id} //= $self->product_obj->classification_id;
+ return $self->{classification_id};
}
sub classification {
- my ($self) = @_;
- return '' if $self->{error};
- $self->{classification} //= $self->product_obj->classification->name;
- return $self->{classification};
+ my ($self) = @_;
+ return '' if $self->{error};
+ $self->{classification} //= $self->product_obj->classification->name;
+ return $self->{classification};
}
sub default_bug_status {
- my $class = shift;
- # XXX This should just call new_bug_statuses when the UI accepts closed
- # bug statuses instead of accepting them as a parameter.
- my @statuses = @_;
-
- my $status;
- if (scalar(@statuses) == 1) {
- $status = $statuses[0]->name;
- }
- else {
- $status = ($statuses[0]->name ne 'UNCONFIRMED')
- ? $statuses[0]->name : $statuses[1]->name;
- }
+ my $class = shift;
+
+ # XXX This should just call new_bug_statuses when the UI accepts closed
+ # bug statuses instead of accepting them as a parameter.
+ my @statuses = @_;
- return $status;
+ my $status;
+ if (scalar(@statuses) == 1) {
+ $status = $statuses[0]->name;
+ }
+ else {
+ $status
+ = ($statuses[0]->name ne 'UNCONFIRMED')
+ ? $statuses[0]->name
+ : $statuses[1]->name;
+ }
+
+ return $status;
}
sub dependson {
- my ($self) = @_;
- return $self->{'dependson'} if exists $self->{'dependson'};
- return [] if $self->{'error'};
- $self->{'dependson'} =
- EmitDependList("blocked", "dependson", $self->bug_id);
- return $self->{'dependson'};
+ my ($self) = @_;
+ return $self->{'dependson'} if exists $self->{'dependson'};
+ return [] if $self->{'error'};
+ $self->{'dependson'} = EmitDependList("blocked", "dependson", $self->bug_id);
+ return $self->{'dependson'};
}
sub depends_on_obj {
- my ($self) = @_;
- $self->{depends_on_obj} ||= $self->_bugs_in_order($self->dependson);
- return $self->{depends_on_obj};
+ my ($self) = @_;
+ $self->{depends_on_obj} ||= $self->_bugs_in_order($self->dependson);
+ return $self->{depends_on_obj};
}
sub duplicates {
- my $self = shift;
- return $self->{duplicates} if exists $self->{duplicates};
- return [] if $self->{error};
- $self->{duplicates} = Bugzilla::Bug->new_from_list($self->duplicate_ids);
- return $self->{duplicates};
+ my $self = shift;
+ return $self->{duplicates} if exists $self->{duplicates};
+ return [] if $self->{error};
+ $self->{duplicates} = Bugzilla::Bug->new_from_list($self->duplicate_ids);
+ return $self->{duplicates};
}
sub duplicate_ids {
- my $self = shift;
- return $self->{duplicate_ids} if exists $self->{duplicate_ids};
- return [] if $self->{error};
+ my $self = shift;
+ return $self->{duplicate_ids} if exists $self->{duplicate_ids};
+ return [] if $self->{error};
- my $dbh = Bugzilla->dbh;
- $self->{duplicate_ids} =
- $dbh->selectcol_arrayref('SELECT dupe FROM duplicates WHERE dupe_of = ?',
- undef, $self->id);
- return $self->{duplicate_ids};
+ my $dbh = Bugzilla->dbh;
+ $self->{duplicate_ids}
+ = $dbh->selectcol_arrayref('SELECT dupe FROM duplicates WHERE dupe_of = ?',
+ undef, $self->id);
+ return $self->{duplicate_ids};
}
sub flag_types {
- my ($self) = @_;
- return $self->{'flag_types'} if exists $self->{'flag_types'};
- return [] if $self->{'error'};
+ my ($self) = @_;
+ return $self->{'flag_types'} if exists $self->{'flag_types'};
+ return [] if $self->{'error'};
- my $vars = { target_type => 'bug',
- product_id => $self->{product_id},
- component_id => $self->{component_id},
- bug_id => $self->bug_id };
+ my $vars = {
+ target_type => 'bug',
+ product_id => $self->{product_id},
+ component_id => $self->{component_id},
+ bug_id => $self->bug_id
+ };
- $self->{'flag_types'} = Bugzilla::Flag->_flag_types($vars);
- return $self->{'flag_types'};
+ $self->{'flag_types'} = Bugzilla::Flag->_flag_types($vars);
+ return $self->{'flag_types'};
}
sub flags {
- my $self = shift;
+ my $self = shift;
- # Don't cache it as it must be in sync with ->flag_types.
- $self->{flags} = [map { @{$_->{flags}} } @{$self->flag_types}];
- return $self->{flags};
+ # Don't cache it as it must be in sync with ->flag_types.
+ $self->{flags} = [map { @{$_->{flags}} } @{$self->flag_types}];
+ return $self->{flags};
}
sub isopened {
- my $self = shift;
- unless (exists $self->{isopened}) {
- $self->{isopened} = is_open_state($self->{bug_status}) ? 1 : 0;
- }
- return $self->{isopened};
+ my $self = shift;
+ unless (exists $self->{isopened}) {
+ $self->{isopened} = is_open_state($self->{bug_status}) ? 1 : 0;
+ }
+ return $self->{isopened};
}
sub keywords {
- my ($self) = @_;
- return join(', ', (map { $_->name } @{$self->keyword_objects}));
+ my ($self) = @_;
+ return join(', ', (map { $_->name } @{$self->keyword_objects}));
}
# XXX At some point, this should probably replace the normal "keywords" sub.
sub keyword_objects {
- my $self = shift;
- return $self->{'keyword_objects'} if defined $self->{'keyword_objects'};
- return [] if $self->{'error'};
+ my $self = shift;
+ return $self->{'keyword_objects'} if defined $self->{'keyword_objects'};
+ return [] if $self->{'error'};
- my $dbh = Bugzilla->dbh;
- my $ids = $dbh->selectcol_arrayref(
- "SELECT keywordid FROM keywords WHERE bug_id = ?", undef, $self->id);
- $self->{'keyword_objects'} = Bugzilla::Keyword->new_from_list($ids);
- return $self->{'keyword_objects'};
+ my $dbh = Bugzilla->dbh;
+ my $ids
+ = $dbh->selectcol_arrayref("SELECT keywordid FROM keywords WHERE bug_id = ?",
+ undef, $self->id);
+ $self->{'keyword_objects'} = Bugzilla::Keyword->new_from_list($ids);
+ return $self->{'keyword_objects'};
}
sub comments {
- my ($self, $params) = @_;
- return [] if $self->{'error'};
- $params ||= {};
-
- if (!defined $self->{'comments'}) {
- $self->{'comments'} = Bugzilla::Comment->match({ bug_id => $self->id });
- my $count = 0;
- state $is_mysql = Bugzilla->dbh->isa('Bugzilla::DB::Mysql') ? 1 : 0;
- foreach my $comment (@{ $self->{'comments'} }) {
- $comment->{count} = $count++;
- $comment->{bug} = $self;
- # XXX - hack for MySQL. Convert [U+....] back into its Unicode
- # equivalent for characters above U+FFFF as MySQL older than 5.5.3
- # cannot store them, see Bugzilla::Comment::_check_thetext().
- if ($is_mysql) {
- # Perl 5.13.8 and older complain about non-characters.
- no warnings 'utf8';
- $comment->{thetext} =~ s/\x{FDD0}\[U\+((?:[1-9A-F]|10)[0-9A-F]{4})\]\x{FDD1}/chr(hex $1)/eg
- }
- }
- # Some bugs may have no comments when upgrading old installations.
- Bugzilla::Comment->preload($self->{'comments'}) if $count;
- }
- my @comments = @{ $self->{'comments'} };
-
- my $order = $params->{order}
- || Bugzilla->user->setting('comment_sort_order');
- if ($order ne 'oldest_to_newest') {
- @comments = reverse @comments;
- if ($order eq 'newest_to_oldest_desc_first') {
- unshift(@comments, pop @comments);
- }
- }
-
- if ($params->{after}) {
- my $from = datetime_from($params->{after});
- @comments = grep { datetime_from($_->creation_ts) > $from } @comments;
- }
- if ($params->{to}) {
- my $to = datetime_from($params->{to});
- @comments = grep { datetime_from($_->creation_ts) <= $to } @comments;
- }
- return \@comments;
+ my ($self, $params) = @_;
+ return [] if $self->{'error'};
+ $params ||= {};
+
+ if (!defined $self->{'comments'}) {
+ $self->{'comments'} = Bugzilla::Comment->match({bug_id => $self->id});
+ my $count = 0;
+ state $is_mysql = Bugzilla->dbh->isa('Bugzilla::DB::Mysql') ? 1 : 0;
+ foreach my $comment (@{$self->{'comments'}}) {
+ $comment->{count} = $count++;
+ $comment->{bug} = $self;
+
+ # XXX - hack for MySQL. Convert [U+....] back into its Unicode
+ # equivalent for characters above U+FFFF as MySQL older than 5.5.3
+ # cannot store them, see Bugzilla::Comment::_check_thetext().
+ if ($is_mysql) {
+
+ # Perl 5.13.8 and older complain about non-characters.
+ no warnings 'utf8';
+ $comment->{thetext}
+ =~ s/\x{FDD0}\[U\+((?:[1-9A-F]|10)[0-9A-F]{4})\]\x{FDD1}/chr(hex $1)/eg;
+ }
+ }
+
+ # Some bugs may have no comments when upgrading old installations.
+ Bugzilla::Comment->preload($self->{'comments'}) if $count;
+ }
+ my @comments = @{$self->{'comments'}};
+
+ my $order = $params->{order} || Bugzilla->user->setting('comment_sort_order');
+ if ($order ne 'oldest_to_newest') {
+ @comments = reverse @comments;
+ if ($order eq 'newest_to_oldest_desc_first') {
+ unshift(@comments, pop @comments);
+ }
+ }
+
+ if ($params->{after}) {
+ my $from = datetime_from($params->{after});
+ @comments = grep { datetime_from($_->creation_ts) > $from } @comments;
+ }
+ if ($params->{to}) {
+ my $to = datetime_from($params->{to});
+ @comments = grep { datetime_from($_->creation_ts) <= $to } @comments;
+ }
+ return \@comments;
}
sub new_bug_statuses {
- my ($class, $product) = @_;
- my $user = Bugzilla->user;
+ my ($class, $product) = @_;
+ my $user = Bugzilla->user;
- # Construct the list of allowable statuses.
- my @statuses = @{ Bugzilla::Bug->statuses_available($product) };
+ # Construct the list of allowable statuses.
+ my @statuses = @{Bugzilla::Bug->statuses_available($product)};
- # If the user has no privs...
- unless ($user->in_group('editbugs', $product->id)
- || $user->in_group('canconfirm', $product->id))
- {
- # ... use UNCONFIRMED if available, else use the first status of the list.
- my ($unconfirmed) = grep { $_->name eq 'UNCONFIRMED' } @statuses;
-
- # Because of an apparent Perl bug, "$unconfirmed || $statuses[0]" doesn't
- # work, so we're using an "?:" operator. See bug 603314 for details.
- @statuses = ($unconfirmed ? $unconfirmed : $statuses[0]);
- }
+ # If the user has no privs...
+ unless ($user->in_group('editbugs', $product->id)
+ || $user->in_group('canconfirm', $product->id))
+ {
+ # ... use UNCONFIRMED if available, else use the first status of the list.
+ my ($unconfirmed) = grep { $_->name eq 'UNCONFIRMED' } @statuses;
+
+ # Because of an apparent Perl bug, "$unconfirmed || $statuses[0]" doesn't
+ # work, so we're using an "?:" operator. See bug 603314 for details.
+ @statuses = ($unconfirmed ? $unconfirmed : $statuses[0]);
+ }
- return \@statuses;
+ return \@statuses;
}
# This is needed by xt/search.t.
sub percentage_complete {
- my $self = shift;
- return undef if $self->{'error'} || !Bugzilla->user->is_timetracker;
- my $remaining = $self->remaining_time;
- my $actual = $self->actual_time;
- my $total = $remaining + $actual;
- return undef if $total == 0;
- # Search.pm truncates this value to an integer, so we want to as well,
- # since this is mostly used in a test where its value needs to be
- # identical to what the database will return.
- return int(100 * ($actual / $total));
+ my $self = shift;
+ return undef if $self->{'error'} || !Bugzilla->user->is_timetracker;
+ my $remaining = $self->remaining_time;
+ my $actual = $self->actual_time;
+ my $total = $remaining + $actual;
+ return undef if $total == 0;
+
+ # Search.pm truncates this value to an integer, so we want to as well,
+ # since this is mostly used in a test where its value needs to be
+ # identical to what the database will return.
+ return int(100 * ($actual / $total));
}
sub product {
- my ($self) = @_;
- return '' if $self->{error};
- $self->{product} //= $self->product_obj->name;
- return $self->{product};
+ my ($self) = @_;
+ return '' if $self->{error};
+ $self->{product} //= $self->product_obj->name;
+ return $self->{product};
}
# XXX This should eventually replace the "product" subroutine.
sub product_obj {
- my $self = shift;
- return {} if $self->{error};
- $self->{product_obj} ||=
- new Bugzilla::Product({ id => $self->{product_id}, cache => 1 });
- return $self->{product_obj};
+ my $self = shift;
+ return {} if $self->{error};
+ $self->{product_obj}
+ ||= new Bugzilla::Product({id => $self->{product_id}, cache => 1});
+ return $self->{product_obj};
}
sub qa_contact {
- my ($self) = @_;
- return $self->{'qa_contact_obj'} if exists $self->{'qa_contact_obj'};
- return undef if $self->{'error'};
+ my ($self) = @_;
+ return $self->{'qa_contact_obj'} if exists $self->{'qa_contact_obj'};
+ return undef if $self->{'error'};
- if (Bugzilla->params->{'useqacontact'} && $self->{'qa_contact'}) {
- $self->{'qa_contact_obj'} = new Bugzilla::User({ id => $self->{'qa_contact'}, cache => 1 });
- } else {
- $self->{'qa_contact_obj'} = undef;
- }
- return $self->{'qa_contact_obj'};
+ if (Bugzilla->params->{'useqacontact'} && $self->{'qa_contact'}) {
+ $self->{'qa_contact_obj'}
+ = new Bugzilla::User({id => $self->{'qa_contact'}, cache => 1});
+ }
+ else {
+ $self->{'qa_contact_obj'} = undef;
+ }
+ return $self->{'qa_contact_obj'};
}
sub reporter {
- my ($self) = @_;
- return $self->{'reporter'} if exists $self->{'reporter'};
- $self->{'reporter_id'} = 0 if $self->{'error'};
- $self->{'reporter'} = new Bugzilla::User({ id => $self->{'reporter_id'}, cache => 1 });
- return $self->{'reporter'};
+ my ($self) = @_;
+ return $self->{'reporter'} if exists $self->{'reporter'};
+ $self->{'reporter_id'} = 0 if $self->{'error'};
+ $self->{'reporter'}
+ = new Bugzilla::User({id => $self->{'reporter_id'}, cache => 1});
+ return $self->{'reporter'};
}
sub see_also {
- my ($self) = @_;
- return [] if $self->{'error'};
- if (!exists $self->{see_also}) {
- my $ids = Bugzilla->dbh->selectcol_arrayref(
- 'SELECT id FROM bug_see_also WHERE bug_id = ?',
- undef, $self->id);
+ my ($self) = @_;
+ return [] if $self->{'error'};
+ if (!exists $self->{see_also}) {
+ my $ids
+ = Bugzilla->dbh->selectcol_arrayref(
+ 'SELECT id FROM bug_see_also WHERE bug_id = ?',
+ undef, $self->id);
- my $bug_urls = Bugzilla::BugUrl->new_from_list($ids);
+ my $bug_urls = Bugzilla::BugUrl->new_from_list($ids);
- $self->{see_also} = $bug_urls;
- }
- return $self->{see_also};
+ $self->{see_also} = $bug_urls;
+ }
+ return $self->{see_also};
}
sub status {
- my $self = shift;
- return undef if $self->{'error'};
+ my $self = shift;
+ return undef if $self->{'error'};
- $self->{'status'} ||= new Bugzilla::Status({name => $self->{'bug_status'}});
- return $self->{'status'};
+ $self->{'status'} ||= new Bugzilla::Status({name => $self->{'bug_status'}});
+ return $self->{'status'};
}
sub statuses_available {
- my ($invocant, $product) = @_;
+ my ($invocant, $product) = @_;
- my @statuses;
+ my @statuses;
- if (ref $invocant) {
- return [] if $invocant->{'error'};
+ if (ref $invocant) {
+ return [] if $invocant->{'error'};
- return $invocant->{'statuses_available'}
- if defined $invocant->{'statuses_available'};
+ return $invocant->{'statuses_available'}
+ if defined $invocant->{'statuses_available'};
- @statuses = @{ $invocant->status->can_change_to };
- $product = $invocant->product_obj;
- } else {
- @statuses = @{ Bugzilla::Status->can_change_to };
- }
+ @statuses = @{$invocant->status->can_change_to};
+ $product = $invocant->product_obj;
+ }
+ else {
+ @statuses = @{Bugzilla::Status->can_change_to};
+ }
- # UNCONFIRMED is only a valid status if it is enabled in this product.
- if (!$product->allows_unconfirmed) {
- @statuses = grep { $_->name ne 'UNCONFIRMED' } @statuses;
- }
+ # UNCONFIRMED is only a valid status if it is enabled in this product.
+ if (!$product->allows_unconfirmed) {
+ @statuses = grep { $_->name ne 'UNCONFIRMED' } @statuses;
+ }
- if (ref $invocant) {
- my $available = $invocant->_refine_available_statuses(@statuses);
- $invocant->{'statuses_available'} = $available;
- return $available;
- }
+ if (ref $invocant) {
+ my $available = $invocant->_refine_available_statuses(@statuses);
+ $invocant->{'statuses_available'} = $available;
+ return $available;
+ }
- return \@statuses;
+ return \@statuses;
}
sub _refine_available_statuses {
- my $self = shift;
- my @statuses = @_;
-
- my @available;
- foreach my $status (@statuses) {
- # Make sure this is a legal status transition
- next if !$self->check_can_change_field(
- 'bug_status', $self->status->name, $status->name);
- push(@available, $status);
- }
+ my $self = shift;
+ my @statuses = @_;
- # If this bug has an inactive status set, it should still be in the list.
- if (!grep($_->name eq $self->status->name, @available)) {
- unshift(@available, $self->status);
- }
-
- return \@available;
+ my @available;
+ foreach my $status (@statuses) {
+
+ # Make sure this is a legal status transition
+ next
+ if !$self->check_can_change_field('bug_status', $self->status->name,
+ $status->name);
+ push(@available, $status);
+ }
+
+ # If this bug has an inactive status set, it should still be in the list.
+ if (!grep($_->name eq $self->status->name, @available)) {
+ unshift(@available, $self->status);
+ }
+
+ return \@available;
}
sub show_attachment_flags {
- my ($self) = @_;
- return $self->{'show_attachment_flags'}
- if exists $self->{'show_attachment_flags'};
- return 0 if $self->{'error'};
+ my ($self) = @_;
+ return $self->{'show_attachment_flags'}
+ if exists $self->{'show_attachment_flags'};
+ return 0 if $self->{'error'};
- # The number of types of flags that can be set on attachments to this bug
- # and the number of flags on those attachments. One of these counts must be
- # greater than zero in order for the "flags" column to appear in the table
- # of attachments.
- my $num_attachment_flag_types = Bugzilla::FlagType::count(
- { 'target_type' => 'attachment',
- 'product_id' => $self->{'product_id'},
- 'component_id' => $self->{'component_id'} });
- my $num_attachment_flags = Bugzilla::Flag->count(
- { 'target_type' => 'attachment',
- 'bug_id' => $self->bug_id });
+ # The number of types of flags that can be set on attachments to this bug
+ # and the number of flags on those attachments. One of these counts must be
+ # greater than zero in order for the "flags" column to appear in the table
+ # of attachments.
+ my $num_attachment_flag_types = Bugzilla::FlagType::count({
+ 'target_type' => 'attachment',
+ 'product_id' => $self->{'product_id'},
+ 'component_id' => $self->{'component_id'}
+ });
+ my $num_attachment_flags = Bugzilla::Flag->count(
+ {'target_type' => 'attachment', 'bug_id' => $self->bug_id});
- $self->{'show_attachment_flags'} =
- ($num_attachment_flag_types || $num_attachment_flags);
+ $self->{'show_attachment_flags'}
+ = ($num_attachment_flag_types || $num_attachment_flags);
- return $self->{'show_attachment_flags'};
+ return $self->{'show_attachment_flags'};
}
sub groups {
- my $self = shift;
- return $self->{'groups'} if exists $self->{'groups'};
- return [] if $self->{'error'};
+ my $self = shift;
+ return $self->{'groups'} if exists $self->{'groups'};
+ return [] if $self->{'error'};
+
+ my $dbh = Bugzilla->dbh;
+ my @groups;
+
+ # Some of this stuff needs to go into Bugzilla::User
+
+ # For every group, we need to know if there is ANY bug_group_map
+ # record putting the current bug in that group and if there is ANY
+ # user_group_map record putting the user in that group.
+ # The LEFT JOINs are checking for record existence.
+ #
+ my $grouplist = Bugzilla->user->groups_as_string;
+ my $sth
+ = $dbh->prepare("SELECT DISTINCT groups.id, name, description,"
+ . " CASE WHEN bug_group_map.group_id IS NOT NULL"
+ . " THEN 1 ELSE 0 END,"
+ . " CASE WHEN groups.id IN($grouplist) THEN 1 ELSE 0 END,"
+ . " isactive, membercontrol, othercontrol"
+ . " FROM groups"
+ . " LEFT JOIN bug_group_map"
+ . " ON bug_group_map.group_id = groups.id"
+ . " AND bug_id = ?"
+ . " LEFT JOIN group_control_map"
+ . " ON group_control_map.group_id = groups.id"
+ . " AND group_control_map.product_id = ? "
+ . " WHERE isbuggroup = 1"
+ . " ORDER BY description");
+ $sth->execute($self->{'bug_id'}, $self->{'product_id'});
+
+ while (
+ my (
+ $groupid, $name, $description, $ison,
+ $ingroup, $isactive, $membercontrol, $othercontrol
+ )
+ = $sth->fetchrow_array()
+ )
+ {
+
+ $membercontrol ||= 0;
+
+ # For product groups, we only want to use the group if either
+ # (1) The bit is set and not required, or
+ # (2) The group is Shown or Default for members and
+ # the user is a member of the group.
+ if (
+ $ison
+ || ( $isactive
+ && $ingroup
+ && ( ($membercontrol == CONTROLMAPDEFAULT)
+ || ($membercontrol == CONTROLMAPSHOWN)))
+ )
+ {
+ my $ismandatory = $isactive && ($membercontrol == CONTROLMAPMANDATORY);
- my $dbh = Bugzilla->dbh;
- my @groups;
-
- # Some of this stuff needs to go into Bugzilla::User
-
- # For every group, we need to know if there is ANY bug_group_map
- # record putting the current bug in that group and if there is ANY
- # user_group_map record putting the user in that group.
- # The LEFT JOINs are checking for record existence.
- #
- my $grouplist = Bugzilla->user->groups_as_string;
- my $sth = $dbh->prepare(
- "SELECT DISTINCT groups.id, name, description," .
- " CASE WHEN bug_group_map.group_id IS NOT NULL" .
- " THEN 1 ELSE 0 END," .
- " CASE WHEN groups.id IN($grouplist) THEN 1 ELSE 0 END," .
- " isactive, membercontrol, othercontrol" .
- " FROM groups" .
- " LEFT JOIN bug_group_map" .
- " ON bug_group_map.group_id = groups.id" .
- " AND bug_id = ?" .
- " LEFT JOIN group_control_map" .
- " ON group_control_map.group_id = groups.id" .
- " AND group_control_map.product_id = ? " .
- " WHERE isbuggroup = 1" .
- " ORDER BY description");
- $sth->execute($self->{'bug_id'},
- $self->{'product_id'});
-
- while (my ($groupid, $name, $description, $ison, $ingroup, $isactive,
- $membercontrol, $othercontrol) = $sth->fetchrow_array()) {
-
- $membercontrol ||= 0;
-
- # For product groups, we only want to use the group if either
- # (1) The bit is set and not required, or
- # (2) The group is Shown or Default for members and
- # the user is a member of the group.
- if ($ison ||
- ($isactive && $ingroup
- && (($membercontrol == CONTROLMAPDEFAULT)
- || ($membercontrol == CONTROLMAPSHOWN))
- ))
+ push(
+ @groups,
{
- my $ismandatory = $isactive
- && ($membercontrol == CONTROLMAPMANDATORY);
-
- push (@groups, { "bit" => $groupid,
- "name" => $name,
- "ison" => $ison,
- "ingroup" => $ingroup,
- "mandatory" => $ismandatory,
- "description" => $description });
+ "bit" => $groupid,
+ "name" => $name,
+ "ison" => $ison,
+ "ingroup" => $ingroup,
+ "mandatory" => $ismandatory,
+ "description" => $description
}
+ );
}
+ }
- $self->{'groups'} = \@groups;
+ $self->{'groups'} = \@groups;
- return $self->{'groups'};
+ return $self->{'groups'};
}
sub groups_in {
- my $self = shift;
- return $self->{'groups_in'} if exists $self->{'groups_in'};
- return [] if $self->{'error'};
- my $group_ids = Bugzilla->dbh->selectcol_arrayref(
- 'SELECT group_id FROM bug_group_map WHERE bug_id = ?',
- undef, $self->id);
- $self->{'groups_in'} = Bugzilla::Group->new_from_list($group_ids);
- return $self->{'groups_in'};
+ my $self = shift;
+ return $self->{'groups_in'} if exists $self->{'groups_in'};
+ return [] if $self->{'error'};
+ my $group_ids
+ = Bugzilla->dbh->selectcol_arrayref(
+ 'SELECT group_id FROM bug_group_map WHERE bug_id = ?',
+ undef, $self->id);
+ $self->{'groups_in'} = Bugzilla::Group->new_from_list($group_ids);
+ return $self->{'groups_in'};
}
sub in_group {
- my ($self, $group) = @_;
- return grep($_->id == $group->id, @{$self->groups_in}) ? 1 : 0;
+ my ($self, $group) = @_;
+ return grep($_->id == $group->id, @{$self->groups_in}) ? 1 : 0;
}
sub user {
- my $self = shift;
- return $self->{'user'} if exists $self->{'user'};
- return {} if $self->{'error'};
-
- my $user = Bugzilla->user;
- my $prod_id = $self->{'product_id'};
-
- my $editbugs = $user->in_group('editbugs', $prod_id);
- my $is_reporter = $user->id == $self->{reporter_id} ? 1 : 0;
- my $is_assignee = $user->id == $self->{'assigned_to'} ? 1 : 0;
- my $is_qa_contact = Bugzilla->params->{'useqacontact'}
- && $self->{'qa_contact'}
- && $user->id == $self->{'qa_contact'} ? 1 : 0;
-
- my $canedit = $editbugs || $is_assignee || $is_qa_contact;
- my $canconfirm = $editbugs || $user->in_group('canconfirm', $prod_id);
- my $has_any_role = $is_reporter || $is_assignee || $is_qa_contact;
-
- $self->{'user'} = {canconfirm => $canconfirm,
- canedit => $canedit,
- isreporter => $is_reporter,
- has_any_role => $has_any_role};
- return $self->{'user'};
+ my $self = shift;
+ return $self->{'user'} if exists $self->{'user'};
+ return {} if $self->{'error'};
+
+ my $user = Bugzilla->user;
+ my $prod_id = $self->{'product_id'};
+
+ my $editbugs = $user->in_group('editbugs', $prod_id);
+ my $is_reporter = $user->id == $self->{reporter_id} ? 1 : 0;
+ my $is_assignee = $user->id == $self->{'assigned_to'} ? 1 : 0;
+ my $is_qa_contact
+ = Bugzilla->params->{'useqacontact'}
+ && $self->{'qa_contact'}
+ && $user->id == $self->{'qa_contact'} ? 1 : 0;
+
+ my $canedit = $editbugs || $is_assignee || $is_qa_contact;
+ my $canconfirm = $editbugs || $user->in_group('canconfirm', $prod_id);
+ my $has_any_role = $is_reporter || $is_assignee || $is_qa_contact;
+
+ $self->{'user'} = {
+ canconfirm => $canconfirm,
+ canedit => $canedit,
+ isreporter => $is_reporter,
+ has_any_role => $has_any_role
+ };
+ return $self->{'user'};
}
# This is intended to get values that can be selected by the user in the
# UI. It should not be used for security or validation purposes.
sub choices {
- my $self = shift;
- return $self->{'choices'} if exists $self->{'choices'};
- return {} if $self->{'error'};
- my $user = Bugzilla->user;
-
- my @products = @{ $user->get_enterable_products };
- # The current product is part of the popup, even if new bugs are no longer
- # allowed for that product
- if (!grep($_->name eq $self->product_obj->name, @products)) {
- unshift(@products, $self->product_obj);
- }
- my %class_ids = map { $_->classification_id => 1 } @products;
- my $classifications =
- Bugzilla::Classification->new_from_list([keys %class_ids]);
-
- my %choices = (
- bug_status => $self->statuses_available,
- classification => $classifications,
- product => \@products,
- component => $self->product_obj->components,
- version => $self->product_obj->versions,
- target_milestone => $self->product_obj->milestones,
- );
-
- my $resolution_field = new Bugzilla::Field({ name => 'resolution' });
- # Don't include the empty resolution in drop-downs.
- my @resolutions = grep($_->name, @{ $resolution_field->legal_values });
- $choices{'resolution'} = \@resolutions;
-
- foreach my $key (keys %choices) {
- my $value = $self->$key;
- $choices{$key} = [grep { $_->is_active || $_->name eq $value } @{ $choices{$key} }];
- }
-
- $self->{'choices'} = \%choices;
- return $self->{'choices'};
+ my $self = shift;
+ return $self->{'choices'} if exists $self->{'choices'};
+ return {} if $self->{'error'};
+ my $user = Bugzilla->user;
+
+ my @products = @{$user->get_enterable_products};
+
+ # The current product is part of the popup, even if new bugs are no longer
+ # allowed for that product
+ if (!grep($_->name eq $self->product_obj->name, @products)) {
+ unshift(@products, $self->product_obj);
+ }
+ my %class_ids = map { $_->classification_id => 1 } @products;
+ my $classifications
+ = Bugzilla::Classification->new_from_list([keys %class_ids]);
+
+ my %choices = (
+ bug_status => $self->statuses_available,
+ classification => $classifications,
+ product => \@products,
+ component => $self->product_obj->components,
+ version => $self->product_obj->versions,
+ target_milestone => $self->product_obj->milestones,
+ );
+
+ my $resolution_field = new Bugzilla::Field({name => 'resolution'});
+
+ # Don't include the empty resolution in drop-downs.
+ my @resolutions = grep($_->name, @{$resolution_field->legal_values});
+ $choices{'resolution'} = \@resolutions;
+
+ foreach my $key (keys %choices) {
+ my $value = $self->$key;
+ $choices{$key}
+ = [grep { $_->is_active || $_->name eq $value } @{$choices{$key}}];
+ }
+
+ $self->{'choices'} = \%choices;
+ return $self->{'choices'};
}
# Convenience Function. If you need speed, use this. If you need
@@ -3989,11 +4144,11 @@ sub choices {
# Queries the database for the bug with a given alias, and returns
# the ID of the bug if it exists or the undefined value if it doesn't.
sub bug_alias_to_id {
- my ($alias) = @_;
- my $dbh = Bugzilla->dbh;
- trick_taint($alias);
- return $dbh->selectrow_array(
- "SELECT bug_id FROM bugs_aliases WHERE alias = ?", undef, $alias);
+ my ($alias) = @_;
+ my $dbh = Bugzilla->dbh;
+ trick_taint($alias);
+ return $dbh->selectrow_array("SELECT bug_id FROM bugs_aliases WHERE alias = ?",
+ undef, $alias);
}
#####################################################################
@@ -4003,21 +4158,26 @@ sub bug_alias_to_id {
# Returns a list of currently active and editable bug fields,
# including multi-select fields.
sub editable_bug_fields {
- my @fields = Bugzilla->dbh->bz_table_columns('bugs');
- # Add multi-select fields
- push(@fields, map { $_->name } @{Bugzilla->fields({obsolete => 0,
- type => FIELD_TYPE_MULTI_SELECT})});
- # Obsolete custom fields are not editable.
- my @obsolete_fields = @{ Bugzilla->fields({obsolete => 1, custom => 1}) };
- @obsolete_fields = map { $_->name } @obsolete_fields;
- foreach my $remove ("bug_id", "reporter", "creation_ts", "delta_ts",
- "lastdiffed", @obsolete_fields)
- {
- my $location = firstidx { $_ eq $remove } @fields;
- # Ensure field exists before attempting to remove it.
- splice(@fields, $location, 1) if ($location > -1);
- }
- return @fields;
+ my @fields = Bugzilla->dbh->bz_table_columns('bugs');
+
+ # Add multi-select fields
+ push(@fields,
+ map { $_->name }
+ @{Bugzilla->fields({obsolete => 0, type => FIELD_TYPE_MULTI_SELECT})});
+
+ # Obsolete custom fields are not editable.
+ my @obsolete_fields = @{Bugzilla->fields({obsolete => 1, custom => 1})};
+ @obsolete_fields = map { $_->name } @obsolete_fields;
+ foreach
+ my $remove ("bug_id", "reporter", "creation_ts", "delta_ts", "lastdiffed",
+ @obsolete_fields)
+ {
+ my $location = firstidx { $_ eq $remove } @fields;
+
+ # Ensure field exists before attempting to remove it.
+ splice(@fields, $location, 1) if ($location > -1);
+ }
+ return @fields;
}
# XXX - When Bug::update() will be implemented, we should make this routine
@@ -4025,103 +4185,107 @@ sub editable_bug_fields {
# Join with bug_status and bugs tables to show bugs with open statuses first,
# and then the others
sub EmitDependList {
- my ($my_field, $target_field, $bug_id, $exclude_resolved) = @_;
- my $cache = Bugzilla->request_cache->{bug_dependency_list} ||= {};
+ my ($my_field, $target_field, $bug_id, $exclude_resolved) = @_;
+ my $cache = Bugzilla->request_cache->{bug_dependency_list} ||= {};
- my $dbh = Bugzilla->dbh;
- $exclude_resolved = $exclude_resolved ? 1 : 0;
- my $is_open_clause = $exclude_resolved ? 'AND is_open = 1' : '';
+ my $dbh = Bugzilla->dbh;
+ $exclude_resolved = $exclude_resolved ? 1 : 0;
+ my $is_open_clause = $exclude_resolved ? 'AND is_open = 1' : '';
- $cache->{"${target_field}_sth_$exclude_resolved"} ||= $dbh->prepare(
- "SELECT $target_field
+ $cache->{"${target_field}_sth_$exclude_resolved"} ||= $dbh->prepare(
+ "SELECT $target_field
FROM dependencies
INNER JOIN bugs ON dependencies.$target_field = bugs.bug_id
INNER JOIN bug_status ON bugs.bug_status = bug_status.value
WHERE $my_field = ? $is_open_clause
- ORDER BY is_open DESC, $target_field");
+ ORDER BY is_open DESC, $target_field"
+ );
- return $dbh->selectcol_arrayref(
- $cache->{"${target_field}_sth_$exclude_resolved"},
- undef, $bug_id);
+ return $dbh->selectcol_arrayref(
+ $cache->{"${target_field}_sth_$exclude_resolved"},
+ undef, $bug_id);
}
# Creates a lot of bug objects in the same order as the input array.
sub _bugs_in_order {
- my ($self, $bug_ids) = @_;
- return [] unless @$bug_ids;
+ my ($self, $bug_ids) = @_;
+ return [] unless @$bug_ids;
- my %bug_map;
- my $dbh = Bugzilla->dbh;
+ my %bug_map;
+ my $dbh = Bugzilla->dbh;
- # there's no need to load bugs from the database if they are already in the
- # object-cache
- my @missing_ids;
- foreach my $bug_id (@$bug_ids) {
- if (my $bug = Bugzilla::Bug->object_cache_get($bug_id)) {
- $bug_map{$bug_id} = $bug;
- }
- else {
- push @missing_ids, $bug_id;
- }
+ # there's no need to load bugs from the database if they are already in the
+ # object-cache
+ my @missing_ids;
+ foreach my $bug_id (@$bug_ids) {
+ if (my $bug = Bugzilla::Bug->object_cache_get($bug_id)) {
+ $bug_map{$bug_id} = $bug;
}
- if (@missing_ids) {
- my $bugs = Bugzilla::Bug->new_from_list(\@missing_ids);
- $bug_map{$_->id} = $_ foreach @$bugs;
+ else {
+ push @missing_ids, $bug_id;
}
+ }
+ if (@missing_ids) {
+ my $bugs = Bugzilla::Bug->new_from_list(\@missing_ids);
+ $bug_map{$_->id} = $_ foreach @$bugs;
+ }
- # Dependencies are often displayed using their aliases instead of their
- # bug ID. Load them all at once.
- my $rows = $dbh->selectall_arrayref(
- 'SELECT bug_id, alias FROM bugs_aliases WHERE ' .
- $dbh->sql_in('bug_id', $bug_ids) . ' ORDER BY alias');
+ # Dependencies are often displayed using their aliases instead of their
+ # bug ID. Load them all at once.
+ my $rows
+ = $dbh->selectall_arrayref('SELECT bug_id, alias FROM bugs_aliases WHERE '
+ . $dbh->sql_in('bug_id', $bug_ids)
+ . ' ORDER BY alias');
- foreach my $row (@$rows) {
- my ($bug_id, $alias) = @$row;
- $bug_map{$bug_id}->{alias} ||= [];
- push @{ $bug_map{$bug_id}->{alias} }, $alias;
- }
- # Make sure all bugs have their alias attribute set.
- $bug_map{$_}->{alias} ||= [] foreach @$bug_ids;
+ foreach my $row (@$rows) {
+ my ($bug_id, $alias) = @$row;
+ $bug_map{$bug_id}->{alias} ||= [];
+ push @{$bug_map{$bug_id}->{alias}}, $alias;
+ }
+
+ # Make sure all bugs have their alias attribute set.
+ $bug_map{$_}->{alias} ||= [] foreach @$bug_ids;
- return [ map { $bug_map{$_} } @$bug_ids ];
+ return [map { $bug_map{$_} } @$bug_ids];
}
# Get the activity of a bug, starting from $starttime (if given).
# This routine assumes Bugzilla::Bug->check has been previously called.
sub get_activity {
- my ($self, $attach_id, $starttime, $include_comment_tags) = @_;
- my $dbh = Bugzilla->dbh;
- my $user = Bugzilla->user;
-
- # Arguments passed to the SQL query.
- my @args = ($self->id);
-
- # Only consider changes since $starttime, if given.
- my $datepart = "";
- if (defined $starttime) {
- trick_taint($starttime);
- push (@args, $starttime);
- $datepart = "AND bug_when > ?";
- }
-
- my $attachpart = "";
- if ($attach_id) {
- push(@args, $attach_id);
- $attachpart = "AND bugs_activity.attach_id = ?";
- }
-
- # Only includes attachments the user is allowed to see.
- my $suppjoins = "";
- my $suppwhere = "";
- if (!$user->is_insider) {
- $suppjoins = "LEFT JOIN attachments
+ my ($self, $attach_id, $starttime, $include_comment_tags) = @_;
+ my $dbh = Bugzilla->dbh;
+ my $user = Bugzilla->user;
+
+ # Arguments passed to the SQL query.
+ my @args = ($self->id);
+
+ # Only consider changes since $starttime, if given.
+ my $datepart = "";
+ if (defined $starttime) {
+ trick_taint($starttime);
+ push(@args, $starttime);
+ $datepart = "AND bug_when > ?";
+ }
+
+ my $attachpart = "";
+ if ($attach_id) {
+ push(@args, $attach_id);
+ $attachpart = "AND bugs_activity.attach_id = ?";
+ }
+
+ # Only includes attachments the user is allowed to see.
+ my $suppjoins = "";
+ my $suppwhere = "";
+ if (!$user->is_insider) {
+ $suppjoins = "LEFT JOIN attachments
ON attachments.attach_id = bugs_activity.attach_id";
- $suppwhere = "AND COALESCE(attachments.isprivate, 0) = 0";
- }
+ $suppwhere = "AND COALESCE(attachments.isprivate, 0) = 0";
+ }
- my $query = "SELECT fielddefs.name, bugs_activity.attach_id, " .
- $dbh->sql_date_format('bugs_activity.bug_when', '%Y.%m.%d %H:%i:%s') .
- " AS bug_when, bugs_activity.removed, bugs_activity.added, profiles.login_name,
+ my $query
+ = "SELECT fielddefs.name, bugs_activity.attach_id, "
+ . $dbh->sql_date_format('bugs_activity.bug_when', '%Y.%m.%d %H:%i:%s')
+ . " AS bug_when, bugs_activity.removed, bugs_activity.added, profiles.login_name,
bugs_activity.comment_id
FROM bugs_activity
$suppjoins
@@ -4134,24 +4298,26 @@ sub get_activity {
$attachpart
$suppwhere ";
- if (Bugzilla->params->{'comment_taggers_group'}
- && $include_comment_tags
- && !$attach_id)
- {
- # Only includes comment tag activity for comments the user is allowed to see.
- $suppjoins = "";
- $suppwhere = "";
- if (!Bugzilla->user->is_insider) {
- $suppjoins = "INNER JOIN longdescs
+ if ( Bugzilla->params->{'comment_taggers_group'}
+ && $include_comment_tags
+ && !$attach_id)
+ {
+ # Only includes comment tag activity for comments the user is allowed to see.
+ $suppjoins = "";
+ $suppwhere = "";
+ if (!Bugzilla->user->is_insider) {
+ $suppjoins = "INNER JOIN longdescs
ON longdescs.comment_id = longdescs_tags_activity.comment_id";
- $suppwhere = "AND longdescs.isprivate = 0";
- }
+ $suppwhere = "AND longdescs.isprivate = 0";
+ }
- $query .= "
+ $query .= "
UNION ALL
SELECT 'comment_tag' AS name,
- NULL AS attach_id," .
- $dbh->sql_date_format('longdescs_tags_activity.bug_when', '%Y.%m.%d %H:%i:%s') . " AS bug_when,
+ NULL AS attach_id,"
+ . $dbh->sql_date_format('longdescs_tags_activity.bug_when',
+ '%Y.%m.%d %H:%i:%s')
+ . " AS bug_when,
longdescs_tags_activity.removed,
longdescs_tags_activity.added,
profiles.login_name,
@@ -4163,168 +4329,177 @@ sub get_activity {
$datepart
$suppwhere
";
- push @args, $self->id;
- push @args, $starttime if defined $starttime;
- }
-
- $query .= "ORDER BY bug_when, comment_id";
+ push @args, $self->id;
+ push @args, $starttime if defined $starttime;
+ }
- my $list = $dbh->selectall_arrayref($query, undef, @args);
+ $query .= "ORDER BY bug_when, comment_id";
- my @operations;
- my $operation = {};
- my $changes = [];
- my $incomplete_data = 0;
+ my $list = $dbh->selectall_arrayref($query, undef, @args);
- foreach my $entry (@$list) {
- my ($fieldname, $attachid, $when, $removed, $added, $who, $comment_id) = @$entry;
- my %change;
- my $activity_visible = 1;
+ my @operations;
+ my $operation = {};
+ my $changes = [];
+ my $incomplete_data = 0;
- # check if the user should see this field's activity
- if (grep { $fieldname eq $_ } TIMETRACKING_FIELDS) {
- $activity_visible = $user->is_timetracker;
- }
- elsif ($fieldname eq 'longdescs.isprivate'
- && !$user->is_insider && $added)
- {
- $activity_visible = 0;
- }
- else {
- $activity_visible = 1;
- }
+ foreach my $entry (@$list) {
+ my ($fieldname, $attachid, $when, $removed, $added, $who, $comment_id)
+ = @$entry;
+ my %change;
+ my $activity_visible = 1;
- if ($activity_visible) {
- # Check for the results of an old Bugzilla data corruption bug
- if (($added eq '?' && $removed eq '?')
- || ($added =~ /^\? / || $removed =~ /^\? /)) {
- $incomplete_data = 1;
- }
-
- # An operation, done by 'who' at time 'when', has a number of
- # 'changes' associated with it.
- # If this is the start of a new operation, store the data from the
- # previous one, and set up the new one.
- if ($operation->{'who'}
- && ($who ne $operation->{'who'}
- || $when ne $operation->{'when'}))
- {
- $operation->{'changes'} = $changes;
- push (@operations, $operation);
-
- # Create new empty anonymous data structures.
- $operation = {};
- $changes = [];
- }
-
- # If this is the same field as the previous item, then concatenate
- # the data into the same change.
- if ($operation->{'who'} && $who eq $operation->{'who'}
- && $when eq $operation->{'when'}
- && $fieldname eq $operation->{'fieldname'}
- && ($comment_id || 0) == ($operation->{'comment_id'} || 0)
- && ($attachid || 0) == ($operation->{'attachid'} || 0))
- {
- my $old_change = pop @$changes;
- $removed = join_activity_entries($fieldname, $old_change->{'removed'}, $removed);
- $added = join_activity_entries($fieldname, $old_change->{'added'}, $added);
- }
- $operation->{'who'} = $who;
- $operation->{'when'} = $when;
- $operation->{'fieldname'} = $change{'fieldname'} = $fieldname;
- $operation->{'attachid'} = $change{'attachid'} = $attachid;
- $change{'removed'} = $removed;
- $change{'added'} = $added;
-
- if ($comment_id) {
- $operation->{comment_id} = $change{'comment'} = Bugzilla::Comment->new($comment_id);
- }
-
- push (@$changes, \%change);
- }
+ # check if the user should see this field's activity
+ if (grep { $fieldname eq $_ } TIMETRACKING_FIELDS) {
+ $activity_visible = $user->is_timetracker;
}
-
- if ($operation->{'who'}) {
- $operation->{'changes'} = $changes;
- push (@operations, $operation);
+ elsif ($fieldname eq 'longdescs.isprivate' && !$user->is_insider && $added) {
+ $activity_visible = 0;
}
+ else {
+ $activity_visible = 1;
+ }
+
+ if ($activity_visible) {
- return(\@operations, $incomplete_data);
+ # Check for the results of an old Bugzilla data corruption bug
+ if ( ($added eq '?' && $removed eq '?')
+ || ($added =~ /^\? / || $removed =~ /^\? /))
+ {
+ $incomplete_data = 1;
+ }
+
+ # An operation, done by 'who' at time 'when', has a number of
+ # 'changes' associated with it.
+ # If this is the start of a new operation, store the data from the
+ # previous one, and set up the new one.
+ if ($operation->{'who'}
+ && ($who ne $operation->{'who'} || $when ne $operation->{'when'}))
+ {
+ $operation->{'changes'} = $changes;
+ push(@operations, $operation);
+
+ # Create new empty anonymous data structures.
+ $operation = {};
+ $changes = [];
+ }
+
+ # If this is the same field as the previous item, then concatenate
+ # the data into the same change.
+ if ( $operation->{'who'}
+ && $who eq $operation->{'who'}
+ && $when eq $operation->{'when'}
+ && $fieldname eq $operation->{'fieldname'}
+ && ($comment_id || 0) == ($operation->{'comment_id'} || 0)
+ && ($attachid || 0) == ($operation->{'attachid'} || 0))
+ {
+ my $old_change = pop @$changes;
+ $removed
+ = join_activity_entries($fieldname, $old_change->{'removed'}, $removed);
+ $added = join_activity_entries($fieldname, $old_change->{'added'}, $added);
+ }
+ $operation->{'who'} = $who;
+ $operation->{'when'} = $when;
+ $operation->{'fieldname'} = $change{'fieldname'} = $fieldname;
+ $operation->{'attachid'} = $change{'attachid'} = $attachid;
+ $change{'removed'} = $removed;
+ $change{'added'} = $added;
+
+ if ($comment_id) {
+ $operation->{comment_id} = $change{'comment'}
+ = Bugzilla::Comment->new($comment_id);
+ }
+
+ push(@$changes, \%change);
+ }
+ }
+
+ if ($operation->{'who'}) {
+ $operation->{'changes'} = $changes;
+ push(@operations, $operation);
+ }
+
+ return (\@operations, $incomplete_data);
}
# Update the bugs_activity table to reflect changes made in bugs.
sub LogActivityEntry {
- my ($bug_id, $field, $removed, $added, $user_id, $timestamp, $comment_id,
- $attach_id) = @_;
- my $sth = Bugzilla->dbh->prepare_cached(
- 'INSERT INTO bugs_activity
+ my ($bug_id, $field, $removed, $added, $user_id, $timestamp, $comment_id,
+ $attach_id)
+ = @_;
+ my $sth = Bugzilla->dbh->prepare_cached(
+ 'INSERT INTO bugs_activity
(bug_id, who, bug_when, fieldid, removed, added, comment_id, attach_id)
- VALUES (?, ?, ?, ?, ?, ?, ?, ?)');
-
- # in the case of CCs, deps, and keywords, there's a possibility that someone
- # might try to add or remove a lot of them at once, which might take more
- # space than the activity table allows. We'll solve this by splitting it
- # into multiple entries if it's too long.
- while ($removed || $added) {
- my ($removestr, $addstr) = ($removed, $added);
- if (length($removestr) > MAX_LINE_LENGTH) {
- my $commaposition = find_wrap_point($removed, MAX_LINE_LENGTH);
- $removestr = substr($removed, 0, $commaposition);
- $removed = substr($removed, $commaposition);
- } else {
- $removed = ""; # no more entries
- }
- if (length($addstr) > MAX_LINE_LENGTH) {
- my $commaposition = find_wrap_point($added, MAX_LINE_LENGTH);
- $addstr = substr($added, 0, $commaposition);
- $added = substr($added, $commaposition);
- } else {
- $added = ""; # no more entries
- }
- trick_taint($addstr);
- trick_taint($removestr);
- my $fieldid = get_field_id($field);
- $sth->execute($bug_id, $user_id, $timestamp, $fieldid, $removestr,
- $addstr, $comment_id, $attach_id);
+ VALUES (?, ?, ?, ?, ?, ?, ?, ?)'
+ );
+
+ # in the case of CCs, deps, and keywords, there's a possibility that someone
+ # might try to add or remove a lot of them at once, which might take more
+ # space than the activity table allows. We'll solve this by splitting it
+ # into multiple entries if it's too long.
+ while ($removed || $added) {
+ my ($removestr, $addstr) = ($removed, $added);
+ if (length($removestr) > MAX_LINE_LENGTH) {
+ my $commaposition = find_wrap_point($removed, MAX_LINE_LENGTH);
+ $removestr = substr($removed, 0, $commaposition);
+ $removed = substr($removed, $commaposition);
}
+ else {
+ $removed = ""; # no more entries
+ }
+ if (length($addstr) > MAX_LINE_LENGTH) {
+ my $commaposition = find_wrap_point($added, MAX_LINE_LENGTH);
+ $addstr = substr($added, 0, $commaposition);
+ $added = substr($added, $commaposition);
+ }
+ else {
+ $added = ""; # no more entries
+ }
+ trick_taint($addstr);
+ trick_taint($removestr);
+ my $fieldid = get_field_id($field);
+ $sth->execute(
+ $bug_id, $user_id, $timestamp, $fieldid,
+ $removestr, $addstr, $comment_id, $attach_id
+ );
+ }
}
# Update bug_user_last_visit table
sub update_user_last_visit {
- my ($self, $user, $last_visit_ts) = @_;
- my $lv = Bugzilla::BugUserLastVisit->match({ bug_id => $self->id,
- user_id => $user->id })->[0];
+ my ($self, $user, $last_visit_ts) = @_;
+ my $lv = Bugzilla::BugUserLastVisit->match(
+ {bug_id => $self->id, user_id => $user->id})->[0];
- if ($lv) {
- $lv->set(last_visit_ts => $last_visit_ts);
- $lv->update;
- }
- else {
- Bugzilla::BugUserLastVisit->create({ bug_id => $self->id,
- user_id => $user->id,
- last_visit_ts => $last_visit_ts });
- }
+ if ($lv) {
+ $lv->set(last_visit_ts => $last_visit_ts);
+ $lv->update;
+ }
+ else {
+ Bugzilla::BugUserLastVisit->create(
+ {bug_id => $self->id, user_id => $user->id, last_visit_ts => $last_visit_ts});
+ }
}
# Convert WebService API and email_in.pl field names to internal DB field
# names.
sub map_fields {
- my ($params, $except) = @_;
-
- my %field_values;
- foreach my $field (keys %$params) {
- # Don't allow setting private fields via email_in or the WebService.
- next if $field =~ /^_/;
- my $field_name;
- if ($except->{$field}) {
- $field_name = $field;
- }
- else {
- $field_name = FIELD_MAP->{$field} || $field;
- }
- $field_values{$field_name} = $params->{$field};
+ my ($params, $except) = @_;
+
+ my %field_values;
+ foreach my $field (keys %$params) {
+
+ # Don't allow setting private fields via email_in or the WebService.
+ next if $field =~ /^_/;
+ my $field_name;
+ if ($except->{$field}) {
+ $field_name = $field;
+ }
+ else {
+ $field_name = FIELD_MAP->{$field} || $field;
}
- return \%field_values;
+ $field_values{$field_name} = $params->{$field};
+ }
+ return \%field_values;
}
################################################################################
@@ -4344,164 +4519,187 @@ sub map_fields {
# $PrivilegesRequired - return the reason of the failure, if any
################################################################################
sub check_can_change_field {
- my $self = shift;
- my ($field, $oldvalue, $newvalue, $PrivilegesRequired) = (@_);
- my $user = Bugzilla->user;
+ my $self = shift;
+ my ($field, $oldvalue, $newvalue, $PrivilegesRequired) = (@_);
+ my $user = Bugzilla->user;
+
+ $oldvalue = defined($oldvalue) ? $oldvalue : '';
+ $newvalue = defined($newvalue) ? $newvalue : '';
+
+ # Return true if they haven't changed this field at all.
+ if ($oldvalue eq $newvalue) {
+ return 1;
+ }
+ elsif (ref($newvalue) eq 'ARRAY' && ref($oldvalue) eq 'ARRAY') {
+ my ($removed, $added) = diff_arrays($oldvalue, $newvalue);
+ return 1 if !scalar(@$removed) && !scalar(@$added);
+ }
+ elsif (trim($oldvalue) eq trim($newvalue)) {
+ return 1;
- $oldvalue = defined($oldvalue) ? $oldvalue : '';
- $newvalue = defined($newvalue) ? $newvalue : '';
-
- # Return true if they haven't changed this field at all.
- if ($oldvalue eq $newvalue) {
- return 1;
- } elsif (ref($newvalue) eq 'ARRAY' && ref($oldvalue) eq 'ARRAY') {
- my ($removed, $added) = diff_arrays($oldvalue, $newvalue);
- return 1 if !scalar(@$removed) && !scalar(@$added);
- } elsif (trim($oldvalue) eq trim($newvalue)) {
- return 1;
# numeric fields need to be compared using ==
- } elsif (($field eq 'estimated_time' || $field eq 'remaining_time'
- || $field eq 'work_time')
- && $oldvalue == $newvalue)
+ }
+ elsif (
+ (
+ $field eq 'estimated_time'
+ || $field eq 'remaining_time'
+ || $field eq 'work_time'
+ )
+ && $oldvalue == $newvalue
+ )
+ {
+ return 1;
+ }
+
+ my @priv_results;
+ Bugzilla::Hook::process(
+ 'bug_check_can_change_field',
{
- return 1;
+ bug => $self,
+ field => $field,
+ new_value => $newvalue,
+ old_value => $oldvalue,
+ priv_results => \@priv_results
+ }
+ );
+ if (my $priv_required = first { $_ > 0 } @priv_results) {
+ $$PrivilegesRequired = $priv_required;
+ return 0;
+ }
+ my $allow_found = first { $_ == 0 } @priv_results;
+ if (defined $allow_found) {
+ return 1;
+ }
+
+ # Allow anyone to change comments, or set flags
+ if ($field =~ /^longdesc/ || $field eq 'flagtypes.name') {
+ return 1;
+ }
+
+# If the user isn't allowed to change a field, we must tell them who can.
+# We store the required permission set into the $PrivilegesRequired
+# variable which gets passed to the error template.
+#
+# $PrivilegesRequired = PRIVILEGES_REQUIRED_NONE : no privileges required;
+# $PrivilegesRequired = PRIVILEGES_REQUIRED_REPORTER : the reporter, assignee or an empowered user;
+# $PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE : the assignee or an empowered user;
+# $PrivilegesRequired = PRIVILEGES_REQUIRED_EMPOWERED : an empowered user.
+
+ # Only users in the time-tracking group can change time-tracking fields,
+ # including the deadline.
+ if (grep { $_ eq $field } (TIMETRACKING_FIELDS, 'deadline')) {
+ if (!$user->is_timetracker) {
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_EMPOWERED;
+ return 0;
+ }
+ }
+
+ # Allow anyone with (product-specific) "editbugs" privs to change anything.
+ if ($user->in_group('editbugs', $self->{'product_id'})) {
+ return 1;
+ }
+
+ # *Only* users with (product-specific) "canconfirm" privs can confirm bugs.
+ if ($self->_changes_everconfirmed($field, $oldvalue, $newvalue)) {
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_EMPOWERED;
+ return $user->in_group('canconfirm', $self->{'product_id'});
+ }
+
+ # Make sure that a valid bug ID has been given.
+ if (!$self->{'error'}) {
+
+ # Allow the assignee to change anything else.
+ if ( $self->{'assigned_to'} == $user->id
+ || $self->{'_old_assigned_to'} && $self->{'_old_assigned_to'} == $user->id)
+ {
+ return 1;
}
- my @priv_results;
- Bugzilla::Hook::process('bug_check_can_change_field',
- { bug => $self, field => $field,
- new_value => $newvalue, old_value => $oldvalue,
- priv_results => \@priv_results });
- if (my $priv_required = first { $_ > 0 } @priv_results) {
- $$PrivilegesRequired = $priv_required;
- return 0;
- }
- my $allow_found = first { $_ == 0 } @priv_results;
- if (defined $allow_found) {
- return 1;
+ # Allow the QA contact to change anything else.
+ if (
+ Bugzilla->params->{'useqacontact'}
+ && ( ($self->{'qa_contact'} && $self->{'qa_contact'} == $user->id)
+ || ($self->{'_old_qa_contact'} && $self->{'_old_qa_contact'} == $user->id))
+ )
+ {
+ return 1;
}
+ }
- # Allow anyone to change comments, or set flags
- if ($field =~ /^longdesc/ || $field eq 'flagtypes.name') {
- return 1;
- }
+ # At this point, the user is either the reporter or an
+ # unprivileged user. We first check for fields the reporter
+ # is not allowed to change.
- # If the user isn't allowed to change a field, we must tell them who can.
- # We store the required permission set into the $PrivilegesRequired
- # variable which gets passed to the error template.
- #
- # $PrivilegesRequired = PRIVILEGES_REQUIRED_NONE : no privileges required;
- # $PrivilegesRequired = PRIVILEGES_REQUIRED_REPORTER : the reporter, assignee or an empowered user;
- # $PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE : the assignee or an empowered user;
- # $PrivilegesRequired = PRIVILEGES_REQUIRED_EMPOWERED : an empowered user.
-
- # Only users in the time-tracking group can change time-tracking fields,
- # including the deadline.
- if (grep { $_ eq $field } (TIMETRACKING_FIELDS, 'deadline')) {
- if (!$user->is_timetracker) {
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_EMPOWERED;
- return 0;
- }
- }
-
- # Allow anyone with (product-specific) "editbugs" privs to change anything.
- if ($user->in_group('editbugs', $self->{'product_id'})) {
- return 1;
- }
+ # The reporter may not:
+ # - reassign bugs, unless the bugs are assigned to them;
+ # in that case we will have already returned 1 above
+ # when checking for the assignee of the bug.
+ if ($field eq 'assigned_to') {
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
+ return 0;
+ }
- # *Only* users with (product-specific) "canconfirm" privs can confirm bugs.
- if ($self->_changes_everconfirmed($field, $oldvalue, $newvalue)) {
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_EMPOWERED;
- return $user->in_group('canconfirm', $self->{'product_id'});
- }
+ # - change the QA contact
+ if ($field eq 'qa_contact') {
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
+ return 0;
+ }
- # Make sure that a valid bug ID has been given.
- if (!$self->{'error'}) {
- # Allow the assignee to change anything else.
- if ($self->{'assigned_to'} == $user->id
- || $self->{'_old_assigned_to'} && $self->{'_old_assigned_to'} == $user->id)
- {
- return 1;
- }
+ # - change the target milestone
+ if ($field eq 'target_milestone') {
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
+ return 0;
+ }
- # Allow the QA contact to change anything else.
- if (Bugzilla->params->{'useqacontact'}
- && (($self->{'qa_contact'} && $self->{'qa_contact'} == $user->id)
- || ($self->{'_old_qa_contact'} && $self->{'_old_qa_contact'} == $user->id)))
- {
- return 1;
- }
- }
+ # - change the priority (unless they could have set it originally)
+ if ($field eq 'priority' && !Bugzilla->params->{'letsubmitterchoosepriority'}) {
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
+ return 0;
+ }
- # At this point, the user is either the reporter or an
- # unprivileged user. We first check for fields the reporter
- # is not allowed to change.
-
- # The reporter may not:
- # - reassign bugs, unless the bugs are assigned to them;
- # in that case we will have already returned 1 above
- # when checking for the assignee of the bug.
- if ($field eq 'assigned_to') {
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
- return 0;
- }
- # - change the QA contact
- if ($field eq 'qa_contact') {
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
- return 0;
- }
- # - change the target milestone
- if ($field eq 'target_milestone') {
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
- return 0;
- }
- # - change the priority (unless they could have set it originally)
- if ($field eq 'priority'
- && !Bugzilla->params->{'letsubmitterchoosepriority'})
- {
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
- return 0;
- }
- # - unconfirm bugs (confirming them is handled above)
- if ($field eq 'everconfirmed') {
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
- return 0;
- }
- # - change the status from one open state to another
- if ($field eq 'bug_status'
- && is_open_state($oldvalue) && is_open_state($newvalue))
- {
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
- return 0;
- }
+ # - unconfirm bugs (confirming them is handled above)
+ if ($field eq 'everconfirmed') {
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
+ return 0;
+ }
+
+ # - change the status from one open state to another
+ if ( $field eq 'bug_status'
+ && is_open_state($oldvalue)
+ && is_open_state($newvalue))
+ {
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_ASSIGNEE;
+ return 0;
+ }
- # The reporter is allowed to change anything else.
- if (!$self->{'error'} && $self->{'reporter_id'} == $user->id) {
- return 1;
- }
+ # The reporter is allowed to change anything else.
+ if (!$self->{'error'} && $self->{'reporter_id'} == $user->id) {
+ return 1;
+ }
- # If we haven't returned by this point, then the user doesn't
- # have the necessary permissions to change this field.
- $$PrivilegesRequired = PRIVILEGES_REQUIRED_REPORTER;
- return 0;
+ # If we haven't returned by this point, then the user doesn't
+ # have the necessary permissions to change this field.
+ $$PrivilegesRequired = PRIVILEGES_REQUIRED_REPORTER;
+ return 0;
}
# A helper for check_can_change_field
sub _changes_everconfirmed {
- my ($self, $field, $old, $new) = @_;
- return 1 if $field eq 'everconfirmed';
- if ($field eq 'bug_status') {
- if ($self->everconfirmed) {
- # Moving a confirmed bug to UNCONFIRMED will change everconfirmed.
- return 1 if $new eq 'UNCONFIRMED';
- }
- else {
- # Moving an unconfirmed bug to an open state that isn't
- # UNCONFIRMED will confirm the bug.
- return 1 if (is_open_state($new) and $new ne 'UNCONFIRMED');
- }
+ my ($self, $field, $old, $new) = @_;
+ return 1 if $field eq 'everconfirmed';
+ if ($field eq 'bug_status') {
+ if ($self->everconfirmed) {
+
+ # Moving a confirmed bug to UNCONFIRMED will change everconfirmed.
+ return 1 if $new eq 'UNCONFIRMED';
}
- return 0;
+ else {
+ # Moving an unconfirmed bug to an open state that isn't
+ # UNCONFIRMED will confirm the bug.
+ return 1 if (is_open_state($new) and $new ne 'UNCONFIRMED');
+ }
+ }
+ return 0;
}
#
@@ -4510,72 +4708,77 @@ sub _changes_everconfirmed {
# Validate and return a hash of dependencies
sub ValidateDependencies {
- my $fields = {};
- # These can be arrayrefs or they can be strings.
- $fields->{'dependson'} = shift;
- $fields->{'blocked'} = shift;
- my $id = shift || 0;
-
- unless (defined($fields->{'dependson'})
- || defined($fields->{'blocked'}))
- {
- return;
- }
-
- my $dbh = Bugzilla->dbh;
- my %deps;
- my %deptree;
- my %sth;
- $sth{dependson} = $dbh->prepare('SELECT dependson FROM dependencies WHERE blocked = ?');
- $sth{blocked} = $dbh->prepare('SELECT blocked FROM dependencies WHERE dependson = ?');
-
- foreach my $pair (["blocked", "dependson"], ["dependson", "blocked"]) {
- my ($me, $target) = @{$pair};
- $deptree{$target} = [];
- $deps{$target} = [];
- next unless $fields->{$target};
-
- my %seen;
- my $target_array = ref($fields->{$target}) ? $fields->{$target}
- : [split(/[\s,]+/, $fields->{$target})];
- foreach my $i (@$target_array) {
- if ($id == $i) {
- ThrowUserError("dependency_loop_single");
- }
- if (!exists $seen{$i}) {
- push(@{$deptree{$target}}, $i);
- $seen{$i} = 1;
- }
- }
- # populate $deps{$target} as first-level deps only.
- # and find remainder of dependency tree in $deptree{$target}
- @{$deps{$target}} = @{$deptree{$target}};
- my @stack = @{$deps{$target}};
- while (@stack) {
- my $i = shift @stack;
- my $dep_list = $dbh->selectcol_arrayref($sth{$target}, undef, $i);
- foreach my $t (@$dep_list) {
- # ignore any _current_ dependencies involving this bug,
- # as they will be overwritten with data from the form.
- if ($t != $id && !exists $seen{$t}) {
- push(@{$deptree{$target}}, $t);
- push @stack, $t;
- $seen{$t} = 1;
- }
- }
+ my $fields = {};
+
+ # These can be arrayrefs or they can be strings.
+ $fields->{'dependson'} = shift;
+ $fields->{'blocked'} = shift;
+ my $id = shift || 0;
+
+ unless (defined($fields->{'dependson'}) || defined($fields->{'blocked'})) {
+ return;
+ }
+
+ my $dbh = Bugzilla->dbh;
+ my %deps;
+ my %deptree;
+ my %sth;
+ $sth{dependson}
+ = $dbh->prepare('SELECT dependson FROM dependencies WHERE blocked = ?');
+ $sth{blocked}
+ = $dbh->prepare('SELECT blocked FROM dependencies WHERE dependson = ?');
+
+ foreach my $pair (["blocked", "dependson"], ["dependson", "blocked"]) {
+ my ($me, $target) = @{$pair};
+ $deptree{$target} = [];
+ $deps{$target} = [];
+ next unless $fields->{$target};
+
+ my %seen;
+ my $target_array
+ = ref($fields->{$target})
+ ? $fields->{$target}
+ : [split(/[\s,]+/, $fields->{$target})];
+ foreach my $i (@$target_array) {
+ if ($id == $i) {
+ ThrowUserError("dependency_loop_single");
+ }
+ if (!exists $seen{$i}) {
+ push(@{$deptree{$target}}, $i);
+ $seen{$i} = 1;
+ }
+ }
+
+ # populate $deps{$target} as first-level deps only.
+ # and find remainder of dependency tree in $deptree{$target}
+ @{$deps{$target}} = @{$deptree{$target}};
+ my @stack = @{$deps{$target}};
+ while (@stack) {
+ my $i = shift @stack;
+ my $dep_list = $dbh->selectcol_arrayref($sth{$target}, undef, $i);
+ foreach my $t (@$dep_list) {
+
+ # ignore any _current_ dependencies involving this bug,
+ # as they will be overwritten with data from the form.
+ if ($t != $id && !exists $seen{$t}) {
+ push(@{$deptree{$target}}, $t);
+ push @stack, $t;
+ $seen{$t} = 1;
}
+ }
}
+ }
- my @deps = @{$deptree{'dependson'}};
- my @blocks = @{$deptree{'blocked'}};
- my %union = ();
- my %isect = ();
- foreach my $b (@deps, @blocks) { $union{$b}++ && $isect{$b}++ }
- my @isect = keys %isect;
- if (scalar(@isect) > 0) {
- ThrowUserError("dependency_loop_multi", {'deps' => \@isect});
- }
- return %deps;
+ my @deps = @{$deptree{'dependson'}};
+ my @blocks = @{$deptree{'blocked'}};
+ my %union = ();
+ my %isect = ();
+ foreach my $b (@deps, @blocks) { $union{$b}++ && $isect{$b}++ }
+ my @isect = keys %isect;
+ if (scalar(@isect) > 0) {
+ ThrowUserError("dependency_loop_multi", {'deps' => \@isect});
+ }
+ return %deps;
}
@@ -4584,51 +4787,52 @@ sub ValidateDependencies {
#####################################################################
sub _create_cf_accessors {
- my ($invocant) = @_;
- my $class = ref($invocant) || $invocant;
- return if Bugzilla->request_cache->{"${class}_cf_accessors_created"};
-
- my $fields = Bugzilla->fields({ custom => 1 });
- foreach my $field (@$fields) {
- my $accessor = $class->_accessor_for($field);
- my $name = "${class}::" . $field->name;
- {
- no strict 'refs';
- next if defined *{$name};
- *{$name} = $accessor;
- }
+ my ($invocant) = @_;
+ my $class = ref($invocant) || $invocant;
+ return if Bugzilla->request_cache->{"${class}_cf_accessors_created"};
+
+ my $fields = Bugzilla->fields({custom => 1});
+ foreach my $field (@$fields) {
+ my $accessor = $class->_accessor_for($field);
+ my $name = "${class}::" . $field->name;
+ {
+ no strict 'refs';
+ next if defined *{$name};
+ *{$name} = $accessor;
}
+ }
- Bugzilla->request_cache->{"${class}_cf_accessors_created"} = 1;
+ Bugzilla->request_cache->{"${class}_cf_accessors_created"} = 1;
}
sub _accessor_for {
- my ($class, $field) = @_;
- if ($field->type == FIELD_TYPE_MULTI_SELECT) {
- return $class->_multi_select_accessor($field->name);
- }
- return $class->_cf_accessor($field->name);
+ my ($class, $field) = @_;
+ if ($field->type == FIELD_TYPE_MULTI_SELECT) {
+ return $class->_multi_select_accessor($field->name);
+ }
+ return $class->_cf_accessor($field->name);
}
sub _cf_accessor {
- my ($class, $field) = @_;
- my $accessor = sub {
- my ($self) = @_;
- return $self->{$field};
- };
- return $accessor;
+ my ($class, $field) = @_;
+ my $accessor = sub {
+ my ($self) = @_;
+ return $self->{$field};
+ };
+ return $accessor;
}
sub _multi_select_accessor {
- my ($class, $field) = @_;
- my $accessor = sub {
- my ($self) = @_;
- $self->{$field} ||= Bugzilla->dbh->selectcol_arrayref(
- "SELECT value FROM bug_$field WHERE bug_id = ? ORDER BY value",
- undef, $self->id);
- return $self->{$field};
- };
- return $accessor;
+ my ($class, $field) = @_;
+ my $accessor = sub {
+ my ($self) = @_;
+ $self->{$field}
+ ||= Bugzilla->dbh->selectcol_arrayref(
+ "SELECT value FROM bug_$field WHERE bug_id = ? ORDER BY value",
+ undef, $self->id);
+ return $self->{$field};
+ };
+ return $accessor;
}
1;