blob: 634d36ad1272eb35434837d92f9a5eece499e1c1 [file] [log] [blame]
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This Source Code Form is "Incompatible With Secondary Licenses", as
# defined by the Mozilla Public License, v. 2.0.
package Bugzilla::Field::ChoiceInterface;
use 5.10.1;
use strict;
use warnings;
use Bugzilla::Constants;
use Bugzilla::Error;
use Bugzilla::Field;
use Scalar::Util qw(blessed);
# Helps implement the "field" accessor without subclasses having to
# write code.
sub FIELD_NAME { return $_[0]->DB_TABLE; }
####################
# Subclass Helpers #
####################
sub _check_if_controller {
my $self = shift;
my $vis_fields = $self->controls_visibility_of_fields;
my $values = $self->controlled_values_array;
if (@$vis_fields || @$values) {
ThrowUserError('fieldvalue_is_controller',
{ value => $self, fields => [map($_->name, @$vis_fields)],
vals => $self->controlled_values });
}
}
#############
# Accessors #
#############
sub is_active { return $_[0]->{'isactive'}; }
sub sortkey { return $_[0]->{'sortkey'}; }
sub bug_count {
my $self = shift;
return $self->{bug_count} if defined $self->{bug_count};
my $dbh = Bugzilla->dbh;
my $fname = $self->field->name;
my $count;
if ($self->field->type == FIELD_TYPE_MULTI_SELECT) {
$count = $dbh->selectrow_array("SELECT COUNT(*) FROM bug_$fname
WHERE value = ?", undef, $self->name);
}
else {
$count = $dbh->selectrow_array("SELECT COUNT(*) FROM bugs
WHERE $fname = ?",
undef, $self->name);
}
$self->{bug_count} = $count;
return $count;
}
sub field {
my $invocant = shift;
my $class = ref $invocant || $invocant;
my $cache = Bugzilla->request_cache;
# This is just to make life easier for subclasses. Our auto-generated
# subclasses from Bugzilla::Field::Choice->type() already have this set.
$cache->{"field_$class"} ||=
new Bugzilla::Field({ name => $class->FIELD_NAME });
return $cache->{"field_$class"};
}
sub is_default {
my $self = shift;
my $name = $self->DEFAULT_MAP->{$self->field->name};
# If it doesn't exist in DEFAULT_MAP, then there is no parameter
# related to this field.
return 0 unless $name;
return ($self->name eq Bugzilla->params->{$name}) ? 1 : 0;
}
sub is_static {
my $self = shift;
# If we need to special-case Resolution for *anything* else, it should
# get its own subclass.
if ($self->field->name eq 'resolution') {
return grep($_ eq $self->name, ('', 'FIXED', 'DUPLICATE'))
? 1 : 0;
}
elsif ($self->field->custom) {
return $self->name eq '---' ? 1 : 0;
}
return 0;
}
sub controls_visibility_of_fields {
my $self = shift;
my $dbh = Bugzilla->dbh;
if (!$self->{controls_visibility_of_fields}) {
my $ids = $dbh->selectcol_arrayref(
"SELECT id FROM fielddefs
INNER JOIN field_visibility
ON fielddefs.id = field_visibility.field_id
WHERE value_id = ? AND visibility_field_id = ?", undef,
$self->id, $self->field->id);
$self->{controls_visibility_of_fields} =
Bugzilla::Field->new_from_list($ids);
}
return $self->{controls_visibility_of_fields};
}
sub visibility_value {
my $self = shift;
if ($self->{visibility_value_id}) {
require Bugzilla::Field::Choice;
$self->{visibility_value} ||=
Bugzilla::Field::Choice->type($self->field->value_field)->new(
$self->{visibility_value_id});
}
return $self->{visibility_value};
}
sub controlled_values {
my $self = shift;
return $self->{controlled_values} if defined $self->{controlled_values};
my $fields = $self->field->controls_values_of;
my %controlled_values;
require Bugzilla::Field::Choice;
foreach my $field (@$fields) {
$controlled_values{$field->name} =
Bugzilla::Field::Choice->type($field)
->match({ visibility_value_id => $self->id });
}
$self->{controlled_values} = \%controlled_values;
return $self->{controlled_values};
}
sub controlled_values_array {
my ($self) = @_;
my $values = $self->controlled_values;
return [map { @{ $values->{$_} } } keys %$values];
}
sub is_visible_on_bug {
my ($self, $bug) = @_;
# Values currently set on the bug are always shown.
return 1 if $self->is_set_on_bug($bug);
# Inactive values are, otherwise, never shown.
return 0 if !$self->is_active;
# Values without a visibility value are, otherwise, always shown.
my $visibility_value = $self->visibility_value;
return 1 if !$visibility_value;
# Values with a visibility value are only shown if the visibility
# value is set on the bug.
return $visibility_value->is_set_on_bug($bug);
}
sub is_set_on_bug {
my ($self, $bug) = @_;
my $field_name = $self->FIELD_NAME;
# This allows bug/create/create.html.tmpl to pass in a hashref that
# looks like a bug object.
my $value = blessed($bug) ? $bug->$field_name : $bug->{$field_name};
$value = $value->name if blessed($value);
return 0 if !defined $value;
if ($self->field->type == FIELD_TYPE_BUG_URLS
or $self->field->type == FIELD_TYPE_MULTI_SELECT)
{
return grep($_ eq $self->name, @$value) ? 1 : 0;
}
return $value eq $self->name ? 1 : 0;
}
1;
__END__
=head1 NAME
Bugzilla::Field::ChoiceInterface - Makes an object act like a
Bugzilla::Field::Choice.
=head1 DESCRIPTION
This is an "interface", in the Java sense (sometimes called a "Role"
or a "Mixin" in other languages). L<Bugzilla::Field::Choice> is the
primary implementor of this interface, but other classes also implement
it if they want to "act like" L<Bugzilla::Field::Choice>.
=head1 METHODS
=head2 Accessors
These are in addition to the standard L<Bugzilla::Object> accessors.
=over
=item C<sortkey>
The key that determines the sort order of this item.
=item C<field>
The L<Bugzilla::Field> object that this field value belongs to.
=item C<is_active>
Whether or not this value should appear as an option on bugs that do
not already have it set as the current value.
=item C<is_static>
C<0> if this field value can be renamed or deleted, C<1> otherwise.
=item C<is_default>
C<1> if this is the default value for this field, C<0> otherwise.
=item C<bug_count>
An integer count of the number of bugs that have this value set.
=item C<controls_visibility_of_fields>
Returns an arrayref of L<Bugzilla::Field> objects, representing any
fields whose visibility are controlled by this field value.
=item C<controlled_values>
Tells you which values in B<other> fields appear (become visible) when this
value is set in its field.
Returns a hashref of arrayrefs. The hash keys are the names of fields,
and the values are arrays of objects that implement
C<Bugzilla::Field::ChoiceInterface>, representing values that this value
controls the visibility of, for that field.
=item C<visibility_value>
Returns an object that implements C<Bugzilla::Field::ChoiceInterface>,
which represents the value that needs to be set in order for this
value to appear in the UI.
=item C<is_visible_on_bug>
Returns C<1> if, according to the settings of C<is_active> and
C<visibility_value>, this value should be displayed as an option
when viewing a bug. Returns C<0> otherwise.
Takes a single argument, a L<Bugzilla::Bug> object or a hash with
similar fields to a L<Bugzilla::Bug> object.
=item C<is_set_on_bug>
Returns C<1> if this value is the current value set for its field on
the passed-in L<Bugzilla::Bug> object (or a hash that looks like a
L<Bugzilla::Bug>). For multi-valued fields, we return C<1> if
I<any> of the currently selected values are this value.
Returns C<0> otherwise.
=back
=head1 B<Methods in need of POD>
=over
=item FIELD_NAME
=item controlled_values_array
=back