1401 lines
41 KiB
Perl
1401 lines
41 KiB
Perl
# 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 Original Code is the Bugzilla Bug Tracking System.
|
||
#
|
||
# Contributor(s): Dan Mosedale <dmose@mozilla.org>
|
||
# Frédéric Buclin <LpSolit@gmail.com>
|
||
# Myk Melez <myk@mozilla.org>
|
||
# Greg Hendricks <ghendricks@novell.com>
|
||
#
|
||
# Deep refactoring by Vitaliy Filippov <vitalif@mail.ru>
|
||
# http://wiki.4intra.net/Bugzilla4Intranet
|
||
|
||
=head1 NAME
|
||
|
||
Bugzilla::Field - a particular piece of information about bugs
|
||
and useful routines for form field manipulation
|
||
|
||
=head1 SYNOPSIS
|
||
|
||
use Bugzilla;
|
||
use Data::Dumper;
|
||
|
||
# Display information about all fields.
|
||
print Dumper(Bugzilla->get_fields());
|
||
|
||
# Display information about non-obsolete custom fields.
|
||
print Dumper(Bugzilla->active_custom_fields);
|
||
|
||
use Bugzilla::Field;
|
||
|
||
# Display information about non-obsolete custom fields.
|
||
# Bugzilla->get_fields() is a wrapper around Bugzilla::Field->match(),
|
||
# so both methods take the same arguments.
|
||
print Dumper(Bugzilla::Field->match({ obsolete => 0, custom => 1 }));
|
||
|
||
# Create or update a custom field or field definition.
|
||
my $field = Bugzilla::Field->create(
|
||
{name => 'cf_silly', description => 'Silly', custom => 1});
|
||
|
||
# Instantiate a Field object for an existing field.
|
||
my $field = new Bugzilla::Field({name => 'qacontact_accessible'});
|
||
if ($field->obsolete) {
|
||
print $field->description . " is obsolete\n";
|
||
}
|
||
|
||
# Validation Routines
|
||
$fieldid = get_field_id($fieldname);
|
||
|
||
=head1 DESCRIPTION
|
||
|
||
Field.pm defines field objects, which represent the particular pieces
|
||
of information that Bugzilla stores about bugs.
|
||
|
||
This package also provides functions for dealing with CGI form fields.
|
||
|
||
C<Bugzilla::Field> is an implementation of L<Bugzilla::Object>, and
|
||
so provides all of the methods available in L<Bugzilla::Object>,
|
||
in addition to what is documented here.
|
||
|
||
=cut
|
||
|
||
package Bugzilla::Field;
|
||
|
||
use strict;
|
||
|
||
use base qw(Exporter Bugzilla::Object);
|
||
@Bugzilla::Field::EXPORT = qw(get_field_id update_visibility_values);
|
||
|
||
use Bugzilla::Constants;
|
||
use Bugzilla::Error;
|
||
use Bugzilla::Util;
|
||
require 'Bugzilla/Field/Choice.pm';
|
||
|
||
use Scalar::Util qw(blessed);
|
||
use Encode;
|
||
use JSON;
|
||
use POSIX;
|
||
|
||
###############################
|
||
#### Initialization ####
|
||
###############################
|
||
|
||
use constant DB_TABLE => 'fielddefs';
|
||
use constant LIST_ORDER => 'sortkey, name';
|
||
|
||
use constant DB_COLUMNS => qw(
|
||
id
|
||
name
|
||
description
|
||
type
|
||
custom
|
||
mailhead
|
||
sortkey
|
||
obsolete
|
||
is_mandatory
|
||
clone_bug
|
||
visibility_field_id
|
||
value_field_id
|
||
delta_ts
|
||
has_activity
|
||
add_to_deps
|
||
url
|
||
);
|
||
|
||
use constant REQUIRED_CREATE_FIELDS => qw(name description);
|
||
|
||
use constant VALIDATORS => {
|
||
custom => \&Bugzilla::Object::check_boolean,
|
||
description => \&_check_description,
|
||
clone_bug => \&Bugzilla::Object::check_boolean,
|
||
mailhead => \&Bugzilla::Object::check_boolean,
|
||
obsolete => \&Bugzilla::Object::check_boolean,
|
||
is_mandatory => \&Bugzilla::Object::check_boolean,
|
||
sortkey => \&_check_sortkey,
|
||
type => \&_check_type,
|
||
visibility_field_id => \&_check_visibility_field_id,
|
||
add_to_deps => \&_check_add_to_deps,
|
||
};
|
||
|
||
use constant UPDATE_VALIDATORS => {
|
||
value_field_id => \&_check_value_field_id,
|
||
};
|
||
|
||
use constant UPDATE_COLUMNS => qw(
|
||
description
|
||
mailhead
|
||
sortkey
|
||
obsolete
|
||
is_mandatory
|
||
clone_bug
|
||
visibility_field_id
|
||
value_field_id
|
||
type
|
||
delta_ts
|
||
has_activity
|
||
add_to_deps
|
||
url
|
||
);
|
||
|
||
# How various field types translate into SQL data definitions.
|
||
use constant SQL_DEFINITIONS => {
|
||
# Using commas because these are constants and they shouldn't
|
||
# be auto-quoted by the "=>" operator.
|
||
FIELD_TYPE_FREETEXT, { TYPE => 'varchar(255)' },
|
||
FIELD_TYPE_EXTURL, { TYPE => 'varchar(255)' },
|
||
FIELD_TYPE_SINGLE_SELECT, { TYPE => 'INT4' },
|
||
FIELD_TYPE_TEXTAREA, { TYPE => 'MEDIUMTEXT' },
|
||
FIELD_TYPE_DATETIME, { TYPE => 'DATETIME' },
|
||
FIELD_TYPE_BUG_ID, { TYPE => 'INT4' },
|
||
FIELD_TYPE_NUMERIC, { TYPE => 'NUMERIC', NOTNULL => 1, DEFAULT => '0' },
|
||
};
|
||
|
||
# Field definitions for the fields that ship with Bugzilla.
|
||
# These are used by populate_field_definitions to populate
|
||
# the fielddefs table.
|
||
use constant DEFAULT_FIELD_COLUMNS => [ qw(name description is_mandatory mailhead clone_bug type value_field visibility_field) ];
|
||
use constant DEFAULT_FIELDS => (map { my $i = 0; $_ = { (map { (DEFAULT_FIELD_COLUMNS->[$i++] => $_) } @$_) } } (
|
||
[ 'bug_id', 'Bug ID', 1, 1, 0 ],
|
||
[ 'short_desc', 'Summary', 1, 1, 0, FIELD_TYPE_FREETEXT ],
|
||
[ 'classification', 'Classification', 1, 1, 0, FIELD_TYPE_SINGLE_SELECT ],
|
||
[ 'product', 'Product', 1, 1, 0, FIELD_TYPE_SINGLE_SELECT ],
|
||
[ 'version', 'Version', 0, 1, 1, FIELD_TYPE_SINGLE_SELECT, 'product', 'product' ],
|
||
[ 'rep_platform', 'Platform', 0, 1, 0, FIELD_TYPE_SINGLE_SELECT ],
|
||
[ 'bug_file_loc', 'URL', 0, 1, 1 ],
|
||
[ 'op_sys', 'OS/Version', 0, 1, 1, FIELD_TYPE_SINGLE_SELECT ],
|
||
[ 'bug_status', 'Status', 1, 1, 0, FIELD_TYPE_SINGLE_SELECT ],
|
||
[ 'status_whiteboard', 'Status Whiteboard', 0, 1, 1, 1, FIELD_TYPE_FREETEXT ],
|
||
[ 'keywords', 'Keywords', 0, 1, 1, FIELD_TYPE_KEYWORDS ],
|
||
[ 'resolution', 'Resolution', 0, 1, 0, FIELD_TYPE_SINGLE_SELECT ],
|
||
[ 'bug_severity', 'Severity', 0, 1, 1, FIELD_TYPE_SINGLE_SELECT ],
|
||
[ 'priority', 'Priority', 0, 1, 1, FIELD_TYPE_SINGLE_SELECT ],
|
||
[ 'component', 'Component', 1, 1, 1, FIELD_TYPE_SINGLE_SELECT, 'product' ],
|
||
[ 'assigned_to', 'Assignee', 1, 1, 0 ],
|
||
[ 'reporter', 'Reporter', 1, 1, 0 ],
|
||
[ 'votes', 'Votes', 0, 1, 0 ],
|
||
[ 'qa_contact', 'QA Contact', 0, 1, 0 ],
|
||
[ 'cc', 'CC', 0, 1, 1 ], # Also reporter/assigned_to/qa are added to cloned bug...
|
||
[ 'dependson', 'Depends on', 0, 1, 0 ],
|
||
[ 'blocked', 'Blocks', 0, 1, 0 ],
|
||
[ 'dup_id', 'Duplicate of', 0, 1, 0, FIELD_TYPE_BUG_ID ],
|
||
|
||
[ 'attachments.description', 'Attachment description', 0, 0, 0 ],
|
||
[ 'attachments.filename', 'Attachment filename', 0, 0, 0 ],
|
||
[ 'attachments.mimetype', 'Attachment mime type', 0, 0, 0 ],
|
||
[ 'attachments.ispatch', 'Attachment is patch', 0, 0, 0 ],
|
||
[ 'attachments.isobsolete', 'Attachment is obsolete', 0, 0, 0 ],
|
||
[ 'attachments.isprivate', 'Attachment is private', 0, 0, 0 ],
|
||
[ 'attachments.submitter', 'Attachment creator', 0, 0, 0 ],
|
||
|
||
[ 'target_milestone', 'Target Milestone', 0, 1, 1, FIELD_TYPE_SINGLE_SELECT, 'product', 'product' ],
|
||
[ 'creation_ts', 'Creation time', 1, 0, 0, FIELD_TYPE_DATETIME ],
|
||
[ 'delta_ts', 'Last changed time', 1, 0, 0, FIELD_TYPE_DATETIME ],
|
||
[ 'longdesc', 'Comment', 0, 0, 0 ],
|
||
[ 'longdescs.isprivate', 'Comment is private', 0, 0, 0 ],
|
||
[ 'alias', 'Alias', 0, 1, 0, FIELD_TYPE_FREETEXT ],
|
||
[ 'everconfirmed', 'Ever Confirmed', 0, 0, 0 ],
|
||
[ 'reporter_accessible', 'Reporter Accessible', 0, 1, 0 ],
|
||
[ 'cclist_accessible', 'CC Accessible', 0, 1, 0 ],
|
||
[ 'bug_group', 'Group', 0, 0, 0 ], # FIXME maybe clone_bug=1?
|
||
[ 'estimated_time', 'Estimated Hours', 0, 1, 0, FIELD_TYPE_NUMERIC ],
|
||
[ 'remaining_time', 'Remaining Hours', 0, 0, 0, FIELD_TYPE_NUMERIC ],
|
||
[ 'deadline', 'Deadline', 0, 1, 1, FIELD_TYPE_DATETIME ],
|
||
[ 'commenter', 'Commenter', 0, 0, 0 ],
|
||
[ 'flagtypes.name', 'Flags and Requests', 0, 0, 0 ],
|
||
[ 'requestees.login_name', 'Flag Requestee', 0, 0, 0 ],
|
||
[ 'setters.login_name', 'Flag Setter', 0, 0, 0 ],
|
||
[ 'work_time', 'Hours Worked', 0, 0, 0 ],
|
||
[ 'percentage_complete', 'Percentage Complete', 0, 0, 0 ],
|
||
[ 'content', 'Content', 0, 0, 0 ],
|
||
[ 'attach_data.thedata', 'Attachment data', 0, 0, 0 ],
|
||
[ 'owner_idle_time', 'Time Since Assignee Touched', 0, 0, 0 ],
|
||
[ 'see_also', 'See Also', 0, 1, 0, FIELD_TYPE_BUG_URLS ],
|
||
));
|
||
|
||
################
|
||
# Constructors #
|
||
################
|
||
|
||
# Override match to add is_select.
|
||
sub match
|
||
{
|
||
my $self = shift;
|
||
my ($params) = @_;
|
||
if (delete $params->{is_select})
|
||
{
|
||
$params->{type} = [ FIELD_TYPE_SINGLE_SELECT, FIELD_TYPE_MULTI_SELECT ];
|
||
}
|
||
return $self->SUPER::match(@_);
|
||
}
|
||
|
||
##############
|
||
# Validators #
|
||
##############
|
||
|
||
sub _check_description
|
||
{
|
||
my ($invocant, $desc) = @_;
|
||
$desc = clean_text($desc);
|
||
$desc || ThrowUserError('field_missing_description');
|
||
return $desc;
|
||
}
|
||
|
||
sub _check_name
|
||
{
|
||
my ($invocant, $name, $is_custom) = @_;
|
||
$name = lc(clean_text($name));
|
||
$name || ThrowUserError('field_missing_name');
|
||
|
||
# Don't want to allow a name that might mess up SQL.
|
||
my $name_regex = qr/^[\w\.]+$/;
|
||
# Custom fields have more restrictive name requirements than
|
||
# standard fields.
|
||
$name_regex = qr/^[a-zA-Z0-9_]+$/ if $is_custom;
|
||
# Custom fields can't be named just "cf_", and there is no normal
|
||
# field named just "cf_".
|
||
if ($name !~ $name_regex || $name eq "cf_")
|
||
{
|
||
ThrowUserError('field_invalid_name', { name => $name });
|
||
}
|
||
|
||
# If it's custom, prepend cf_ to the custom field name to distinguish
|
||
# it from standard fields.
|
||
if ($name !~ /^cf_/ && $is_custom)
|
||
{
|
||
$name = 'cf_' . $name;
|
||
}
|
||
|
||
# Assure the name is unique. Names can't be changed, so we don't have
|
||
# to worry about what to do on updates.
|
||
my $field = Bugzilla->get_field($name);
|
||
ThrowUserError('field_already_exists', {'field' => $field }) if $field;
|
||
|
||
return $name;
|
||
}
|
||
|
||
sub _check_sortkey
|
||
{
|
||
my ($invocant, $sortkey) = @_;
|
||
my $skey = $sortkey;
|
||
if (!defined $skey || $skey eq '')
|
||
{
|
||
($sortkey) = Bugzilla->dbh->selectrow_array('SELECT MAX(sortkey) + 100 FROM fielddefs') || 100;
|
||
}
|
||
detaint_natural($sortkey) || ThrowUserError('field_invalid_sortkey', { sortkey => $skey });
|
||
return $sortkey;
|
||
}
|
||
|
||
sub _check_type
|
||
{
|
||
my ($invocant, $type) = @_;
|
||
if (ref $invocant)
|
||
{
|
||
# Do not allow to change type of an existing custom field
|
||
return $invocant->type;
|
||
}
|
||
my $saved_type = $type;
|
||
# The constant here should be updated every time a new,
|
||
# higher field type is added.
|
||
if (!detaint_natural($type) || $type <= FIELD_TYPE_UNKNOWN ||
|
||
$type > FIELD_TYPE_KEYWORDS && $type < FIELD_TYPE_NUMERIC ||
|
||
$type > FIELD_TYPE_BUG_ID_REV)
|
||
{
|
||
ThrowCodeError('invalid_customfield_type', { type => $saved_type });
|
||
}
|
||
elsif ($type == FIELD_TYPE_BUG_URLS || $type == FIELD_TYPE_KEYWORDS)
|
||
{
|
||
ThrowUserError('useless_customfield_type', { type => $type });
|
||
}
|
||
return $type;
|
||
}
|
||
|
||
sub _check_value_field_id
|
||
{
|
||
my ($invocant, $field_id, undef, $type) = @_;
|
||
$type = $invocant->type if !defined $type;
|
||
if ($type == FIELD_TYPE_BUG_ID_REV)
|
||
{
|
||
# For fields of type "reverse relation of BUG_ID field"
|
||
# value_field indicates the needed direct relation
|
||
my $field = Bugzilla->get_field(trim($field_id));
|
||
if (!$field || $field->type != FIELD_TYPE_BUG_ID)
|
||
{
|
||
ThrowUserError('direct_field_needed_for_reverse');
|
||
}
|
||
for (Bugzilla->get_fields({ type => FIELD_TYPE_BUG_ID_REV, value_field_id => $field->id }))
|
||
{
|
||
if (!ref $invocant || $_->id != $invocant->id)
|
||
{
|
||
ThrowUserError('duplicate_reverse_field');
|
||
}
|
||
}
|
||
return $field->id;
|
||
}
|
||
if ($field_id && $type != FIELD_TYPE_SINGLE_SELECT && $type != FIELD_TYPE_MULTI_SELECT)
|
||
{
|
||
ThrowUserError('field_value_control_select_only');
|
||
}
|
||
return $invocant->_check_visibility_field_id($field_id);
|
||
}
|
||
|
||
sub _check_visibility_field_id
|
||
{
|
||
my ($invocant, $field_id) = @_;
|
||
$field_id = trim($field_id);
|
||
return undef if !$field_id;
|
||
my $field = Bugzilla->get_field($field_id);
|
||
if (blessed($invocant) && $field->id == $invocant->id)
|
||
{
|
||
ThrowUserError('field_cant_control_self', { field => $field });
|
||
}
|
||
if (!$field->is_select)
|
||
{
|
||
ThrowUserError('field_control_must_be_select', { field => $field });
|
||
}
|
||
return $field->id;
|
||
}
|
||
|
||
# This has effect only for fields of FIELD_TYPE_BUG_ID type
|
||
# When 1, add field value (bug id) to list of bugs blocked by current
|
||
# When 2, add field value (bug id) to list of bugs depending on current
|
||
sub _check_add_to_deps
|
||
{
|
||
my ($invocant, $value) = @_;
|
||
my %addto = ('' => 0, 1 => 1, 2 => 2, no => 0, blocked => 1, dependson => 2);
|
||
return $addto{$value || ''};
|
||
}
|
||
|
||
=pod
|
||
|
||
=head2 Instance Properties
|
||
|
||
=over
|
||
|
||
=item C<name>
|
||
|
||
the name of the field in the database; begins with "cf_" if field
|
||
is a custom field, but test the value of the boolean "custom" property
|
||
to determine if a given field is a custom field
|
||
|
||
=item C<description>
|
||
|
||
a short string describing the field; displayed to Bugzilla users
|
||
in several places within Bugzilla's UI, f.e. as the form field label
|
||
on the "show bug" page
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub description { return $_[0]->{description} }
|
||
|
||
=over
|
||
|
||
=item C<type>
|
||
|
||
an integer specifying the kind of field this is; values correspond to
|
||
the FIELD_TYPE_* constants in Constants.pm
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub type { return $_[0]->{type} }
|
||
|
||
=over
|
||
|
||
=item C<custom>
|
||
|
||
a boolean specifying whether or not the field is a custom field;
|
||
if true, field name should start "cf_", but use this property to determine
|
||
which fields are custom fields
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub custom { return $_[0]->{custom} }
|
||
|
||
=over
|
||
|
||
=item C<in_new_bugmail>
|
||
|
||
a boolean specifying whether or not the field is displayed in bugmail
|
||
for newly-created bugs;
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub in_new_bugmail { return $_[0]->{mailhead} }
|
||
|
||
=over
|
||
|
||
=item C<sortkey>
|
||
|
||
an integer specifying the sortkey of the field
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub sortkey { return $_[0]->{sortkey} }
|
||
|
||
=over
|
||
|
||
=item C<obsolete>
|
||
|
||
a boolean specifying whether or not the field is obsolete
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub obsolete { return $_[0]->{obsolete} }
|
||
|
||
=over
|
||
|
||
=item C<nullable>
|
||
|
||
a boolean specifying whether empty value is allowed for this field
|
||
|
||
=back
|
||
|
||
=item C<is_mandatory>
|
||
|
||
the reverse of nullable
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub nullable { return !$_[0]->type || $_[0]->type == FIELD_TYPE_BUG_ID_REV || !$_[0]->{is_mandatory} }
|
||
|
||
sub is_mandatory { return !$_[0]->nullable }
|
||
|
||
=over
|
||
|
||
=item C<clone_bug>
|
||
|
||
A boolean specifying whether or not this field should be copied on bug clone
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub clone_bug { return $_[0]->{clone_bug} }
|
||
|
||
=over
|
||
|
||
=item C<is_select>
|
||
|
||
True if this is a C<FIELD_TYPE_SINGLE_SELECT> or C<FIELD_TYPE_MULTI_SELECT>
|
||
field. It is only safe to call L</legal_values> if this is true.
|
||
|
||
=item C<legal_values>
|
||
|
||
Valid values for this field, as an array of L<Bugzilla::Field::Choice>
|
||
objects.
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub is_select
|
||
{
|
||
return ($_[0]->type == FIELD_TYPE_SINGLE_SELECT
|
||
|| $_[0]->type == FIELD_TYPE_MULTI_SELECT) ? 1 : 0;
|
||
}
|
||
|
||
sub has_activity { $_[0]->{has_activity} }
|
||
|
||
sub add_to_deps { $_[0]->type == FIELD_TYPE_BUG_ID && $_[0]->{add_to_deps} }
|
||
|
||
sub url { $_[0]->{url} }
|
||
|
||
sub value_type
|
||
{
|
||
my $self = shift;
|
||
return Bugzilla::Field::Choice->type($self);
|
||
}
|
||
|
||
sub new_choice
|
||
{
|
||
my $self = shift;
|
||
return $self->value_type->new(@_);
|
||
}
|
||
|
||
# Includes disabled values is $include_disabled = true
|
||
sub legal_values
|
||
{
|
||
my $self = shift;
|
||
my ($include_disabled) = @_;
|
||
return [] unless $self->is_select;
|
||
return [ Bugzilla::Field::Choice->type($self)->get_all($include_disabled) ];
|
||
}
|
||
|
||
# Always excludes disabled values
|
||
sub legal_value_names
|
||
{
|
||
my $self = shift;
|
||
return [] unless $self->is_select;
|
||
return [ map { $_->{name} } @{ Bugzilla::Field::Choice->type($self)->get_all_names } ];
|
||
}
|
||
|
||
sub legal_value_names_with_ids
|
||
{
|
||
my $self = shift;
|
||
return [] unless $self->is_select;
|
||
return Bugzilla::Field::Choice->type($self)->get_all_names;
|
||
}
|
||
|
||
# Always excludes disabled values
|
||
sub restricted_legal_values
|
||
{
|
||
my $self = shift;
|
||
my ($controller_value) = @_;
|
||
$controller_value = $controller_value->id if ref $controller_value;
|
||
return $self->legal_values unless $controller_value && $self->value_field_id;
|
||
my $rc_cache = Bugzilla->rc_cache_fields;
|
||
if (!$rc_cache->{$self}->{restricted_legal_values}->{$controller_value})
|
||
{
|
||
my $hash = Bugzilla->fieldvaluecontrol_hash->{$self->value_field_id}->{values}->{$self->id};
|
||
$rc_cache->{$self}->{restricted_legal_values}->{$controller_value} = [
|
||
grep {
|
||
$_->is_static || !exists $hash->{$_->id} ||
|
||
!%{$hash->{$_->id}} || $hash->{$_->id}->{$controller_value}
|
||
} @{$self->legal_values}
|
||
];
|
||
}
|
||
return $rc_cache->{$self}->{restricted_legal_values}->{$controller_value};
|
||
}
|
||
|
||
# Select default values for a named value of controlling field
|
||
sub get_default_values
|
||
{
|
||
my $self = shift;
|
||
my ($controller_value) = @_;
|
||
return [] unless $self->value_field;
|
||
my @values;
|
||
my $field_values = $self->value_field->legal_values;
|
||
foreach my $field_value (@$field_values)
|
||
{
|
||
if ($field_value->{name} eq $controller_value)
|
||
{
|
||
my $cvalues = $self->legal_values;
|
||
foreach my $value (@$cvalues)
|
||
{
|
||
push @values, $value->{value} if $value->is_default_controlled_value($field_value->{id}) && !$value->is_static;
|
||
}
|
||
last;
|
||
}
|
||
}
|
||
return \@values;
|
||
}
|
||
|
||
=pod
|
||
|
||
=over
|
||
|
||
=item C<visibility_field>
|
||
|
||
What field controls this field's visibility? Returns a C<Bugzilla::Field>
|
||
object representing the field that controls this field's visibility.
|
||
|
||
Returns undef if there is no field that controls this field's visibility.
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub visibility_field
|
||
{
|
||
my $self = shift;
|
||
if ($self->{visibility_field_id})
|
||
{
|
||
return Bugzilla->get_field($self->{visibility_field_id});
|
||
}
|
||
return undef;
|
||
}
|
||
|
||
sub visibility_field_id
|
||
{
|
||
my $self = shift;
|
||
return $self->{visibility_field_id};
|
||
}
|
||
|
||
sub visibility_values
|
||
{
|
||
my $self = shift;
|
||
return undef if !$self->visibility_field_id;
|
||
my $h = Bugzilla->fieldvaluecontrol_hash
|
||
->{$self->visibility_field_id}->{fields}->{$self->id};
|
||
return $h && %$h ? $h : undef;
|
||
}
|
||
|
||
sub has_visibility_value
|
||
{
|
||
my $self = shift;
|
||
return 1 if !$self->visibility_field_id;
|
||
my ($value) = @_;
|
||
$value = $value->id if ref $value;
|
||
my $hash = Bugzilla->fieldvaluecontrol_hash
|
||
->{$self->visibility_field_id}->{fields}->{$self->id};
|
||
return !$hash || !%$hash || $hash->{$value};
|
||
}
|
||
|
||
sub null_visibility_values
|
||
{
|
||
my $self = shift;
|
||
return undef if !$self->visibility_field_id;
|
||
my $h = Bugzilla->fieldvaluecontrol_hash
|
||
->{$self->visibility_field_id}->{null}->{$self->id};
|
||
return $h && %$h ? $h : undef;
|
||
}
|
||
|
||
# Check visibility of field for a bug or for a hashref with default value names
|
||
sub check_visibility
|
||
{
|
||
my $self = shift;
|
||
my $bug = shift || return 1;
|
||
my $vf = $self->visibility_field || return 1;
|
||
my $value = bug_or_hash_value($bug, $vf);
|
||
return $value ? $self->has_visibility_value($value) : 1;
|
||
}
|
||
|
||
sub check_is_nullable
|
||
{
|
||
my $self = shift;
|
||
$self->nullable || return 0;
|
||
$self->null_visibility_values || return 1;
|
||
my $bug = shift || return 1;
|
||
my $vf = $self->visibility_field || return 1;
|
||
my $value = bug_or_hash_value($bug, $vf);
|
||
return $value ? $self->null_visibility_values->{$value} : 1;
|
||
}
|
||
|
||
=pod
|
||
|
||
=over
|
||
|
||
=item C<controls_visibility_of>
|
||
|
||
An arrayref of C<Bugzilla::Field> objects, representing fields that this
|
||
field controls the visibility of.
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub controls_visibility_of
|
||
{
|
||
my $self = shift;
|
||
$self->{controls_visibility_of} ||= [ Bugzilla->get_fields({ visibility_field_id => $self->id, obsolete => 0 }) ];
|
||
return $self->{controls_visibility_of};
|
||
}
|
||
|
||
=pod
|
||
|
||
=over
|
||
|
||
=item C<value_field>
|
||
|
||
The Bugzilla::Field that controls the list of values for this field.
|
||
|
||
Returns undef if there is no field that controls this field's visibility.
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub value_field
|
||
{
|
||
my $self = shift;
|
||
if (my $id = $self->value_field_id)
|
||
{
|
||
$self->{value_field} ||= Bugzilla::Field->new($id);
|
||
}
|
||
return $self->{value_field};
|
||
}
|
||
|
||
sub value_field_id
|
||
{
|
||
my $self = shift;
|
||
return undef if !$self->is_select && $self->type != FIELD_TYPE_BUG_ID_REV;
|
||
return $self->{value_field_id};
|
||
}
|
||
|
||
=pod
|
||
|
||
=over
|
||
|
||
=item C<controls_values_of>
|
||
|
||
An arrayref of C<Bugzilla::Field> objects, representing fields that this
|
||
field controls the values of.
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub controls_values_of
|
||
{
|
||
my $self = shift;
|
||
$self->{controls_values_of} ||= [ Bugzilla->get_fields({ value_field_id => $self->id }) ];
|
||
return $self->{controls_values_of};
|
||
}
|
||
|
||
=pod
|
||
|
||
=head2 Instance Mutators
|
||
|
||
These set the particular field that they are named after.
|
||
|
||
They take a single value--the new value for that field.
|
||
|
||
They will throw an error if you try to set the values to something invalid.
|
||
|
||
=over
|
||
|
||
=item C<set_description>
|
||
|
||
=item C<set_clone_bug>
|
||
|
||
=item C<set_obsolete>
|
||
|
||
=item C<set_nullable>
|
||
|
||
=item C<set_sortkey>
|
||
|
||
=item C<set_in_new_bugmail>
|
||
|
||
=item C<set_visibility_field>
|
||
|
||
=item C<set_value_field>
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub set_description { $_[0]->set('description', $_[1]); }
|
||
sub set_clone_bug { $_[0]->set('clone_bug', $_[1]); }
|
||
sub set_obsolete { $_[0]->set('obsolete', $_[1]); }
|
||
sub set_is_mandatory { $_[0]->set('is_mandatory', $_[1]); }
|
||
sub set_sortkey { $_[0]->set('sortkey', $_[1]); }
|
||
sub set_in_new_bugmail { $_[0]->set('mailhead', $_[1]); }
|
||
sub set_add_to_deps { $_[0]->set('add_to_deps', $_[1]); }
|
||
sub set_url { $_[0]->set('url', $_[1]); }
|
||
|
||
sub set_visibility_field
|
||
{
|
||
my ($self, $value) = @_;
|
||
$self->set('visibility_field_id', $value);
|
||
delete $self->{visibility_field};
|
||
}
|
||
|
||
sub set_visibility_values
|
||
{
|
||
my $self = shift;
|
||
my ($value_ids) = @_;
|
||
update_visibility_values($self, 0, $value_ids);
|
||
return $value_ids && @$value_ids;
|
||
}
|
||
|
||
sub set_null_visibility_values
|
||
{
|
||
my $self = shift;
|
||
my ($value_ids) = @_;
|
||
update_visibility_values($self, -1, $value_ids);
|
||
return $value_ids && @$value_ids;
|
||
}
|
||
|
||
sub set_value_field
|
||
{
|
||
my ($self, $value) = @_;
|
||
$self->set('value_field_id', $value);
|
||
delete $self->{value_field};
|
||
}
|
||
|
||
# This is only used internally by upgrade code in Bugzilla::Field.
|
||
sub _set_type
|
||
{
|
||
trick_taint($_[1]);
|
||
$_[0]->{type} = int($_[1]);
|
||
}
|
||
|
||
=pod
|
||
|
||
=head2 Instance Method
|
||
|
||
=over
|
||
|
||
=item C<remove_from_db>
|
||
|
||
Attempts to remove the passed in field from the database.
|
||
Deleting a field is only successful if the field is obsolete and
|
||
there are no values specified (or EVER specified) for the field.
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub remove_from_db
|
||
{
|
||
my $self = shift;
|
||
my $dbh = Bugzilla->dbh;
|
||
|
||
my $name = $self->name;
|
||
|
||
if (!$self->custom)
|
||
{
|
||
ThrowCodeError('field_not_custom', { name => $name });
|
||
}
|
||
|
||
if (!$self->obsolete)
|
||
{
|
||
ThrowUserError('customfield_not_obsolete', { name => $self->name });
|
||
}
|
||
|
||
$dbh->bz_start_transaction();
|
||
|
||
# Check to see if bug activity table has records (should be fast with index)
|
||
my $has_activity = $dbh->selectrow_array("SELECT COUNT(*) FROM bugs_activity WHERE fieldid = ?", undef, $self->id);
|
||
if ($has_activity)
|
||
{
|
||
ThrowUserError('customfield_has_activity', { name => $name });
|
||
}
|
||
|
||
# Check to see if bugs table has records (slow)
|
||
my $bugs_query = "";
|
||
|
||
if ($self->type == FIELD_TYPE_MULTI_SELECT)
|
||
{
|
||
$bugs_query = "SELECT COUNT(*) FROM bug_$name";
|
||
}
|
||
else
|
||
{
|
||
$bugs_query = "SELECT COUNT(*) FROM bugs WHERE $name IS NOT NULL";
|
||
if ($self->type != FIELD_TYPE_BUG_ID && $self->type != FIELD_TYPE_DATETIME)
|
||
{
|
||
$bugs_query .= " AND $name != ''";
|
||
}
|
||
# Ignore the empty single select value
|
||
if ($self->type == FIELD_TYPE_SINGLE_SELECT)
|
||
{
|
||
$bugs_query .= " AND $name IS NOT NULL";
|
||
}
|
||
}
|
||
|
||
my $has_bugs = $dbh->selectrow_array($bugs_query);
|
||
if ($has_bugs)
|
||
{
|
||
ThrowUserError('customfield_has_contents', { name => $name });
|
||
}
|
||
|
||
# Once we reach here, we should be OK to delete.
|
||
$dbh->do('DELETE FROM fielddefs WHERE id = ?', undef, $self->id);
|
||
|
||
my $type = $self->type;
|
||
|
||
# the values for multi-select are stored in a seperate table
|
||
if ($type != FIELD_TYPE_MULTI_SELECT)
|
||
{
|
||
$dbh->bz_drop_column('bugs', $name);
|
||
}
|
||
|
||
if ($self->is_select)
|
||
{
|
||
# Delete the table that holds the legal values for this field.
|
||
$dbh->bz_drop_field_tables($self);
|
||
}
|
||
|
||
$self->set_visibility_values(undef);
|
||
|
||
# Update some other field (refresh the cache)
|
||
Bugzilla->get_field('delta_ts')->touch;
|
||
Bugzilla->refresh_cache_fields;
|
||
|
||
$dbh->bz_commit_transaction();
|
||
}
|
||
|
||
# Overridden update() method - flushes field cache
|
||
sub update
|
||
{
|
||
my $self = shift;
|
||
$self->{delta_ts} = POSIX::strftime('%Y-%m-%d %H:%M:%S', localtime);
|
||
# FIXME Merge something like VALIDATOR_DEPENDENCIES from 4.4
|
||
if ($self->{type} != FIELD_TYPE_BUG_ID)
|
||
{
|
||
$self->{add_to_deps} = 0;
|
||
}
|
||
if ($self->{type} != FIELD_TYPE_EXTURL)
|
||
{
|
||
$self->{url} = undef;
|
||
}
|
||
my ($changes, $old_self) = $self->SUPER::update(@_);
|
||
Bugzilla->refresh_cache_fields;
|
||
return wantarray ? ($changes, $old_self) : $changes;
|
||
}
|
||
|
||
# Update field change timestamp (needed for cache flushing)
|
||
sub touch
|
||
{
|
||
my $self = shift;
|
||
$self->{delta_ts} = POSIX::strftime('%Y-%m-%d %H:%M:%S', localtime);
|
||
$self->update;
|
||
}
|
||
|
||
=pod
|
||
|
||
=head2 Class Methods
|
||
|
||
=over
|
||
|
||
=item C<create>
|
||
|
||
Just like L<Bugzilla::Object/create>. Takes the following parameters:
|
||
|
||
=over
|
||
|
||
=item C<name> B<Required> - The name of the field.
|
||
|
||
=item C<description> B<Required> - The field label to display in the UI.
|
||
|
||
=item C<mailhead> - boolean - Whether this field appears at the
|
||
top of the bugmail for a newly-filed bug. Defaults to 0.
|
||
|
||
=item C<custom> - boolean - True if this is a Custom Field. The field
|
||
will be added to the C<bugs> table if it does not exist. Defaults to 0.
|
||
|
||
=item C<sortkey> - integer - The sortkey of the field. Defaults to 0.
|
||
|
||
C<obsolete> - boolean - Whether this field is obsolete. Defaults to 0.
|
||
|
||
=back
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub create
|
||
{
|
||
my $class = shift;
|
||
my ($params) = @_;
|
||
|
||
# We must set up database schema BEFORE inserting a row into fielddefs!
|
||
$params->{delta_ts} = POSIX::strftime('%Y-%m-%d %H:%M:%S', localtime);
|
||
$class->check_required_create_fields($params);
|
||
my $field_values = $class->run_create_validators($params);
|
||
my $obj = bless $field_values, ref($class)||$class;
|
||
|
||
my $dbh = Bugzilla->dbh;
|
||
if ($obj->custom)
|
||
{
|
||
my $name = $obj->name;
|
||
my $type = $obj->type;
|
||
if (SQL_DEFINITIONS->{$type})
|
||
{
|
||
# Create the database column that stores the data for this field.
|
||
$dbh->bz_add_column('bugs', $name, SQL_DEFINITIONS->{$type});
|
||
}
|
||
|
||
if ($obj->is_select)
|
||
{
|
||
# Create the table that holds the legal values for this field.
|
||
$dbh->bz_add_field_tables($obj);
|
||
}
|
||
|
||
# Add foreign keys
|
||
if ($type == FIELD_TYPE_SINGLE_SELECT)
|
||
{
|
||
$dbh->bz_add_fk('bugs', $name, { TABLE => $obj->name, COLUMN => 'id' });
|
||
}
|
||
elsif ($type == FIELD_TYPE_BUG_ID)
|
||
{
|
||
$dbh->bz_add_fk('bugs', $name, { TABLE => 'bugs', COLUMN => 'bug_id' });
|
||
}
|
||
}
|
||
|
||
# Call real constructor
|
||
my $self = $class->SUPER::create($params);
|
||
|
||
# Refresh fields inside single request
|
||
Bugzilla->refresh_cache_fields;
|
||
|
||
return $self;
|
||
}
|
||
|
||
sub run_create_validators
|
||
{
|
||
my $class = shift;
|
||
my $dbh = Bugzilla->dbh;
|
||
my $params = $class->SUPER::run_create_validators(@_);
|
||
|
||
$params->{name} = $class->_check_name($params->{name}, $params->{custom});
|
||
if (!exists $params->{sortkey})
|
||
{
|
||
$params->{sortkey} = $dbh->selectrow_array("SELECT MAX(sortkey) + 100 FROM fielddefs") || 100;
|
||
}
|
||
|
||
my $type = $params->{type} || 0;
|
||
|
||
if ($params->{custom} && !$type)
|
||
{
|
||
ThrowCodeError('field_type_not_specified');
|
||
}
|
||
|
||
$params->{value_field_id} = $class->_check_value_field_id($params->{value_field_id}, undef, $type);
|
||
|
||
# FIXME Merge something like VALIDATOR_DEPENDENCIES from 4.4
|
||
if ($type != FIELD_TYPE_BUG_ID)
|
||
{
|
||
$params->{add_to_deps} = 0;
|
||
}
|
||
if ($type != FIELD_TYPE_EXTURL)
|
||
{
|
||
$params->{url} = undef;
|
||
}
|
||
|
||
return $params;
|
||
}
|
||
|
||
=over
|
||
|
||
=item C<populate_field_definitions()>
|
||
|
||
Description: Populates the fielddefs table during an installation
|
||
or upgrade.
|
||
|
||
Params: none
|
||
|
||
Returns: nothing
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub populate_field_definitions
|
||
{
|
||
my $dbh = Bugzilla->dbh;
|
||
|
||
my ($has_clone_bug) = $dbh->selectrow_array('SELECT 1 FROM fielddefs WHERE clone_bug AND NOT custom');
|
||
|
||
# Add/update field definitions
|
||
foreach my $def (DEFAULT_FIELDS())
|
||
{
|
||
my $field = new Bugzilla::Field({ name => $def->{name} });
|
||
if ($field)
|
||
{
|
||
$field->set_description($def->{description});
|
||
$field->set_in_new_bugmail($def->{mailhead});
|
||
$field->_set_type($def->{type}) if $def->{type};
|
||
$field->set_clone_bug($def->{clone_bug}) if !$has_clone_bug;
|
||
$field->set_is_mandatory($def->{is_mandatory}) if $def->{is_mandatory};
|
||
$field->set_value_field($dbh->selectrow_array('SELECT id FROM fielddefs WHERE name=?', undef, $def->{value_field})) if $def->{value_field};
|
||
$field->set_visibility_field($dbh->selectrow_array('SELECT id FROM fielddefs WHERE name=?', undef, $def->{visibility_field})) if $def->{visibility_field};
|
||
$field->update();
|
||
}
|
||
else
|
||
{
|
||
Bugzilla::Field->create($def);
|
||
}
|
||
}
|
||
|
||
# DELETE fields which were added only accidentally, or which
|
||
# were never tracked in bugs_activity. Note that you can never
|
||
# delete fields which are used by bugs_activity.
|
||
|
||
# Oops. Bug 163299
|
||
$dbh->do("DELETE FROM fielddefs WHERE name='cc_accessible'");
|
||
# Oops. Bug 215319
|
||
$dbh->do("DELETE FROM fielddefs WHERE name='requesters.login_name'");
|
||
# This field was never tracked in bugs_activity, so it's safe to delete.
|
||
$dbh->do("DELETE FROM fielddefs WHERE name='attachments.thedata'");
|
||
|
||
# MODIFY old field definitions
|
||
|
||
# 2005-11-13 LpSolit@gmail.com - Bug 302599
|
||
# One of the field names was a fragment of SQL code, which is DB dependent.
|
||
# We have to rename it to a real name, which is DB independent.
|
||
my $new_field_name = 'days_elapsed';
|
||
my $field_description = 'Days since bug changed';
|
||
|
||
my ($old_field_id, $old_field_name) = $dbh->selectrow_array(
|
||
'SELECT id, name FROM fielddefs WHERE description = ?',
|
||
undef, $field_description
|
||
);
|
||
|
||
if ($old_field_id && ($old_field_name ne $new_field_name))
|
||
{
|
||
print "SQL fragment found in the 'fielddefs' table...\n";
|
||
print "Old field name: " . $old_field_name . "\n";
|
||
# We have to fix saved searches first. Queries have been escaped
|
||
# before being saved. We have to do the same here to find them.
|
||
$old_field_name = url_quote($old_field_name);
|
||
my $broken_named_queries = $dbh->selectall_arrayref(
|
||
'SELECT userid, name, query FROM namedqueries WHERE ' .
|
||
$dbh->sql_istrcmp('query', '?', 'LIKE'),
|
||
undef, "%=$old_field_name%"
|
||
);
|
||
|
||
my $sth_UpdateQueries = $dbh->prepare(
|
||
'UPDATE namedqueries SET query = ? WHERE userid = ? AND name = ?'
|
||
);
|
||
|
||
print "Fixing saved searches...\n" if scalar @$broken_named_queries;
|
||
foreach my $named_query (@$broken_named_queries)
|
||
{
|
||
my ($userid, $name, $query) = @$named_query;
|
||
$query =~ s/=\Q$old_field_name\E(&|$)/=$new_field_name$1/gi;
|
||
$sth_UpdateQueries->execute($query, $userid, $name);
|
||
}
|
||
|
||
# We now do the same with saved chart series.
|
||
my $broken_series = $dbh->selectall_arrayref(
|
||
'SELECT series_id, query FROM series WHERE ' .
|
||
$dbh->sql_istrcmp('query', '?', 'LIKE'),
|
||
undef, "%=$old_field_name%"
|
||
);
|
||
|
||
my $sth_UpdateSeries = $dbh->prepare('UPDATE series SET query = ? WHERE series_id = ?');
|
||
|
||
print "Fixing saved chart series...\n" if scalar @$broken_series;
|
||
foreach my $series (@$broken_series)
|
||
{
|
||
my ($series_id, $query) = @$series;
|
||
$query =~ s/=\Q$old_field_name\E(&|$)/=$new_field_name$1/gi;
|
||
$sth_UpdateSeries->execute($query, $series_id);
|
||
}
|
||
|
||
# Now that saved searches have been fixed, we can fix the field name.
|
||
print "Fixing the 'fielddefs' table...\n";
|
||
print "New field name: " . $new_field_name . "\n";
|
||
$dbh->do('UPDATE fielddefs SET name = ? WHERE id = ?', undef, $new_field_name, $old_field_id);
|
||
}
|
||
|
||
# This field has to be created separately, or the above upgrade code
|
||
# might not run properly.
|
||
unless (new Bugzilla::Field({ name => $new_field_name }))
|
||
{
|
||
Bugzilla::Field->create({
|
||
name => $new_field_name,
|
||
description => $field_description
|
||
});
|
||
}
|
||
}
|
||
|
||
=pod
|
||
|
||
=over
|
||
|
||
=item C<get_field_id($fieldname)>
|
||
|
||
Description: Returns the ID of the specified field name and throws
|
||
an error if this field does not exist.
|
||
|
||
Params: $name - a field name
|
||
|
||
Returns: the corresponding field ID or an error if the field name
|
||
does not exist.
|
||
|
||
=back
|
||
|
||
=cut
|
||
|
||
sub get_field_id
|
||
{
|
||
my ($name) = @_;
|
||
trick_taint($name);
|
||
my $field = Bugzilla->get_field($name);
|
||
ThrowCodeError('invalid_field_name', { field => $name }) unless $field;
|
||
return $field->id;
|
||
}
|
||
|
||
# Get choice value object for a bug or for a hashref with default value names
|
||
sub bug_or_hash_value
|
||
{
|
||
my ($bug, $vf) = @_;
|
||
my $value;
|
||
if (blessed $bug)
|
||
{
|
||
$value = $bug->get_ids($vf->name);
|
||
}
|
||
else
|
||
{
|
||
$value = $bug->{$vf->name};
|
||
if (!ref $value)
|
||
{
|
||
# FIXME: This does not allow selecting of fields
|
||
# non-uniquely identified by name, as a visibility
|
||
# controller field (for example, "component")
|
||
$value = Bugzilla::Field::Choice->type($vf)->new({ name => $value });
|
||
$value = $value->id if $value;
|
||
}
|
||
}
|
||
return $value;
|
||
}
|
||
|
||
# Shared between Bugzilla::Field and Bugzilla::Field::Choice
|
||
sub update_visibility_values
|
||
{
|
||
my ($controlled_field, $controlled_value_id, $visibility_value_ids) = @_;
|
||
$visibility_value_ids ||= [];
|
||
my $vis_field = $controlled_value_id > 0
|
||
? $controlled_field->value_field
|
||
: $controlled_field->visibility_field;
|
||
if (!$vis_field)
|
||
{
|
||
return undef;
|
||
}
|
||
$controlled_field = Bugzilla->get_field($controlled_field) if !ref $controlled_field;
|
||
$controlled_value_id = int($controlled_value_id);
|
||
if (@$visibility_value_ids)
|
||
{
|
||
my $type = Bugzilla::Field::Choice->type($vis_field);
|
||
$visibility_value_ids = [ map { $_->id } @{ $type->new_from_list($visibility_value_ids) } ];
|
||
}
|
||
Bugzilla->dbh->do(
|
||
"DELETE FROM fieldvaluecontrol WHERE field_id=? AND value_id=?",
|
||
undef, $controlled_field->id, $controlled_value_id);
|
||
if (@$visibility_value_ids)
|
||
{
|
||
my $f = $controlled_field->id;
|
||
Bugzilla->dbh->do(
|
||
"INSERT INTO fieldvaluecontrol (field_id, value_id, visibility_value_id) VALUES ".
|
||
join(",", map { "($f, $controlled_value_id, $_)" } @$visibility_value_ids)
|
||
);
|
||
}
|
||
# Touch the field
|
||
$controlled_field->touch;
|
||
return 1;
|
||
}
|
||
|
||
# FIXME Вот такая у нас сейчас логика... не нравится она мне... Скорее всего, надо делать так:
|
||
# * если записей нет, а visibility_field_id есть - поле не видно никогда. новые поля не видны нигде.
|
||
# * аналогично со значениями; новые значения не видны нигде.
|
||
# * придётся добавить ещё null_field_id, т.к. например target_milestone может быть виден везде, а nullable быть не везде
|
||
# * отдельное поле, от которого зависит дефолтное значение (default_field_id), отдельная таблица
|
||
# для хранения дефолтных значений (field_id, visibility_value_id, default_value). Т.к. это не только для select'ов...
|
||
# (тут точно нужно отдельное поле, т.к. например наборы версий зависят от продукта, но дефолтные версии - от компонента)
|
||
# * и видимо отдельное поле, от которого зависит клонирование (clone_field_id), и хранить (field_id, -2, visibility_value_id)
|
||
sub toggle_value
|
||
{
|
||
my ($f, $v, $vv, $enable) = @_;
|
||
my ($any, $this) = Bugzilla->dbh->selectrow_array(
|
||
'SELECT COUNT(*), SUM(visibility_value_id=?) FROM fieldvaluecontrol WHERE field_id=? AND value_id=?', undef, $vv, $f, $v
|
||
);
|
||
if ($enable && $any && !$this)
|
||
{
|
||
Bugzilla->dbh->do('INSERT INTO fieldvaluecontrol (field_id, value_id, visibility_value_id) VALUES (?, ?, ?)', undef, $f, $v, $vv);
|
||
return 1;
|
||
}
|
||
elsif (!$enable && !$any)
|
||
{
|
||
my $obj = Bugzilla->get_field($f);
|
||
$obj = $v > 0 ? $obj->value_field : $obj->visibility_field;
|
||
# FIXME: Taint bug (5.18.2): $obj->value_type->DB_TABLE becomes tainted
|
||
# and taints SQL query if substituted directly into dbh->do()...
|
||
my $t = $obj->value_type->DB_TABLE;
|
||
Bugzilla->dbh->do(
|
||
'INSERT INTO fieldvaluecontrol (field_id, value_id, visibility_value_id)'.
|
||
'SELECT ?, ?, id FROM '.$t.' WHERE id != ?',
|
||
undef, $f, $v, $vv
|
||
);
|
||
return 0;
|
||
}
|
||
elsif (!$enable && $this)
|
||
{
|
||
Bugzilla->dbh->do(
|
||
'DELETE FROM fieldvaluecontrol WHERE field_id=? AND value_id=? AND visibility_value_id=?',
|
||
undef, $f, $v, $vv
|
||
);
|
||
return 0;
|
||
}
|
||
return undef;
|
||
}
|
||
|
||
sub update_controlled_values
|
||
{
|
||
my ($controlled_field, $controlled_value_ids, $visibility_value_id, $default_value_ids) = @_;
|
||
$controlled_value_ids ||= [];
|
||
my $vis_field = $controlled_field->value_field;
|
||
if (!$vis_field)
|
||
{
|
||
return undef;
|
||
}
|
||
$controlled_field = Bugzilla->get_field($controlled_field) if !ref $controlled_field;
|
||
$visibility_value_id = int($visibility_value_id);
|
||
if ($visibility_value_id)
|
||
{
|
||
my $type = Bugzilla::Field::Choice->type($vis_field);
|
||
$visibility_value_id = $type->new($visibility_value_id)->{id};
|
||
}
|
||
Bugzilla->dbh->do(
|
||
"DELETE FROM fieldvaluecontrol WHERE field_id=? AND visibility_value_id=? AND value_id!=0",
|
||
undef, $controlled_field->id, $visibility_value_id);
|
||
if (@$controlled_value_ids)
|
||
{
|
||
my $type = Bugzilla::Field::Choice->type($controlled_field);
|
||
$controlled_value_ids = [ map { $_->id } @{ $type->new_from_list($controlled_value_ids) } ];
|
||
if ($default_value_ids)
|
||
{
|
||
$default_value_ids = { map { $_->id => 1 } @{ $type->new_from_list($default_value_ids) } };
|
||
}
|
||
my $f = $controlled_field->id;
|
||
my $sql = "INSERT INTO fieldvaluecontrol (field_id, visibility_value_id, value_id, is_default) VALUES ".
|
||
join(",", map { "($f, $visibility_value_id, $_, " . ($default_value_ids->{$_} ? '1' : '0') . ')' } @$controlled_value_ids);
|
||
Bugzilla->dbh->do($sql);
|
||
}
|
||
# Touch the field
|
||
$controlled_field->touch;
|
||
return 1;
|
||
}
|
||
|
||
sub update_default_values
|
||
{
|
||
my ($controlled_field, $visibility_value_id, $default_value_ids) = @_;
|
||
$controlled_field = Bugzilla->get_field($controlled_field) if !ref $controlled_field;
|
||
$visibility_value_id = int($visibility_value_id);
|
||
$default_value_ids = [ map { int $_ } @$default_value_ids || (0) ];
|
||
Bugzilla->dbh->do(
|
||
'UPDATE fieldvaluecontrol SET is_default=(value_id IN ('.join(', ', @$default_value_ids).
|
||
')) WHERE field_id=? AND visibility_value_id=? AND value_id!=0',
|
||
undef, $controlled_field->id, $visibility_value_id
|
||
);
|
||
# Touch the field
|
||
$controlled_field->touch;
|
||
return 1;
|
||
}
|
||
|
||
# Field and value dependency data, intended for use in client JavaScript
|
||
sub json_visibility
|
||
{
|
||
my $self = shift;
|
||
my $data = {
|
||
legal => [ map { [ $_->id, $_->name ] } @{$self->legal_values} ],
|
||
visibility_field => $self->visibility_field ? $self->visibility_field->name : undef,
|
||
value_field => $self->value_field ? $self->value_field->name : undef,
|
||
nullable => $self->nullable ? 1 : 0,
|
||
fields => {},
|
||
values => {},
|
||
null => {},
|
||
};
|
||
my $hash = Bugzilla->fieldvaluecontrol_hash->{$self->id};
|
||
for my $key (qw(fields values null))
|
||
{
|
||
$data->{$key} = { map { Bugzilla->get_field($_)->name => $hash->{$key}->{$_} } keys %{$hash->{$key}} };
|
||
}
|
||
return $data;
|
||
}
|
||
|
||
1;
|
||
__END__
|