summaryrefslogtreecommitdiffstats
path: root/Bugzilla
diff options
context:
space:
mode:
Diffstat (limited to 'Bugzilla')
-rw-r--r--Bugzilla/Field/ChoiceInterface.pm267
1 files changed, 267 insertions, 0 deletions
diff --git a/Bugzilla/Field/ChoiceInterface.pm b/Bugzilla/Field/ChoiceInterface.pm
new file mode 100644
index 000000000..5b796270b
--- /dev/null
+++ b/Bugzilla/Field/ChoiceInterface.pm
@@ -0,0 +1,267 @@
+# -*- Mode: perl; indent-tabs-mode: nil -*-
+#
+# The contents of this file are subject to the Mozilla Public
+# License Version 1.1 (the "License"); you may not use this file
+# except in compliance with the License. You may obtain a copy of
+# the License at http://www.mozilla.org/MPL/
+#
+# Software distributed under the License is distributed on an "AS
+# IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+# implied. See the License for the specific language governing
+# rights and limitations under the License.
+#
+# The Initial Developer of the Original Code is NASA.
+# Portions created by NASA are Copyright (C) 2006 San Jose State
+# University Foundation. All Rights Reserved.
+#
+# The Original Code is the Bugzilla Bug Tracking System.
+#
+# Contributor(s): Max Kanat-Alexander <mkanat@bugzilla.org>
+# Greg Hendricks <ghendricks@novell.com>
+
+package Bugzilla::Field::ChoiceInterface;
+use strict;
+
+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;
+ if (@$vis_fields || scalar(keys %$values)) {
+ ThrowUserError('fieldvalue_is_controller',
+ { value => $self, fields => [map($_->name, @$vis_fields)],
+ vals => $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', 'MOVED', 'DUPLICATE'))
+ ? 1 : 0;
+ }
+ elsif ($self->field->custom) {
+ return $self->name eq '---' ? 1 : 0;
+ }
+ return 0;
+}
+
+sub controls_visibility_of_fields {
+ my $self = shift;
+ $self->{controls_visibility_of_fields} ||= Bugzilla::Field->match(
+ { visibility_field_id => $self->field->id,
+ visibility_value_id => $self->id });
+ 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 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};
+ 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