my $fields = $cache->{fields};
my %requested;
if (my $types = delete $criteria->{type}) {
- $types = ref($types) ? $types : [$types];
+ $types = ref($types) ? $types : [$types];
%requested = map { %{$fields->{by_type}->{$_} || {}} } @$types;
}
else {
if (
(
(!ref $invocant && $is_private)
- || (ref $invocant && $invocant->isprivate != $is_private)
+ || (ref $invocant && $invocant->isprivate != $is_private)
)
&& !Bugzilla->user->is_insider
)
foreach my $word (@words) {
my ($term, $rel_term)
= $dbh->sql_fulltext_search('bugs_fulltext.short_desc', $word);
- push(@where, $term);
+ push(@where, $term);
push(@relevance, $rel_term || $term);
}
ThrowUserError(
'comment_required',
{
- old => $old_status ? $old_status->name : undef,
- new => $new_status->name,
+ old => $old_status ? $old_status->name : undef,
+ new => $new_status->name,
field => 'bug_status'
}
);
# We don't precompile any functions here, that's done specially in
# mod_perl code.
$invocant->_setup_symbols(qw(:no_xhtml :oldstyle_urls :private_tempfiles
- :unique_headers));
+ :unique_headers));
}
BEGIN { __PACKAGE__->_init_bz_cgi_globals() if i_am_cgi(); }
die "The $file file does not exist."
. ' You probably need to run checksetup.pl.',;
}
-
+
return \%params;
}
{name => 'smtp_password', type => 'p', default => ''},
{name => 'smtp_ssl', type => 'b', default => 0, checker => \&check_smtp_ssl},
{name => 'smtp_debug', type => 'b', default => 0},
- {name => 'whinedays', type => 't', default => 7, checker => \&check_numeric},
+ {name => 'whinedays', type => 't', default => 7, checker => \&check_numeric},
{name => 'globalwatchers', type => 't', default => '',},
);
return @param_list;
# so if it doesn't have them, then we're setting up FKs
# for the first time, and should be quieter about it.
my $activity_fk = $self->bz_fk_info('profiles_activity', 'userid');
- my $any_fks = $activity_fk && $activity_fk->{created};
+ my $any_fks = $activity_fk && $activity_fk->{created};
if (!$any_fks) {
say get_text('install_fk_setup');
}
my $tables = $self->selectall_arrayref('SHOW TABLE STATUS');
foreach my $table_status (@$tables) {
my ($table, undef, undef, $row_format) = @$table_status;
- my $table_type = $table_status->[-1];
+ my $table_type = $table_status->[-1];
my $new_row_format = $self->default_row_format($table);
next if lc($table_type) eq 'view';
next if lc($new_row_format) eq 'compact';
# to these index names.
INDEXES => [
value_idx => {FIELDS => ['value'], TYPE => 'UNIQUE'},
- sortkey_idx => ['sortkey', 'value'],
+ sortkey_idx => ['sortkey', 'value'],
visibility_value_id_idx => ['visibility_value_id'],
],
};
flagtypes => {
FIELDS => [
id => {TYPE => 'MEDIUMSERIAL', NOTNULL => 1, PRIMARYKEY => 1},
- name => {TYPE => 'varchar(50)', NOTNULL => 1},
- description => {TYPE => 'MEDIUMTEXT', NOTNULL => 1},
+ name => {TYPE => 'varchar(50)', NOTNULL => 1},
+ description => {TYPE => 'MEDIUMTEXT', NOTNULL => 1},
cc_list => {TYPE => 'varchar(200)'},
- target_type => {TYPE => 'char(1)', NOTNULL => 1, DEFAULT => "'b'"},
- is_active => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'TRUE'},
- is_requestable => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'FALSE'},
- is_requesteeble => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'FALSE'},
- is_multiplicable => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'FALSE'},
- sortkey => {TYPE => 'INT2', NOTNULL => 1, DEFAULT => '0'},
+ target_type => {TYPE => 'char(1)', NOTNULL => 1, DEFAULT => "'b'"},
+ is_active => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'TRUE'},
+ is_requestable => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'FALSE'},
+ is_requesteeble => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'FALSE'},
+ is_multiplicable => {TYPE => 'BOOLEAN', NOTNULL => 1, DEFAULT => 'FALSE'},
+ sortkey => {TYPE => 'INT2', NOTNULL => 1, DEFAULT => '0'},
grant_group_id => {
TYPE => 'INT3',
REFERENCES => {TABLE => 'groups', COLUMN => 'id', DELETE => 'SET NULL'}
],
INDEXES => [
bug_status_value_idx => {FIELDS => ['value'], TYPE => 'UNIQUE'},
- bug_status_sortkey_idx => ['sortkey', 'value'],
+ bug_status_sortkey_idx => ['sortkey', 'value'],
bug_status_visibility_value_id_idx => ['visibility_value_id'],
],
},
FIELDS => dclone(FIELD_TABLE_SCHEMA->{FIELDS}),
INDEXES => [
resolution_value_idx => {FIELDS => ['value'], TYPE => 'UNIQUE'},
- resolution_sortkey_idx => ['sortkey', 'value'],
+ resolution_sortkey_idx => ['sortkey', 'value'],
resolution_visibility_value_id_idx => ['visibility_value_id'],
],
},
FIELDS => dclone(FIELD_TABLE_SCHEMA->{FIELDS}),
INDEXES => [
bug_severity_value_idx => {FIELDS => ['value'], TYPE => 'UNIQUE'},
- bug_severity_sortkey_idx => ['sortkey', 'value'],
+ bug_severity_sortkey_idx => ['sortkey', 'value'],
bug_severity_visibility_value_id_idx => ['visibility_value_id'],
],
},
FIELDS => dclone(FIELD_TABLE_SCHEMA->{FIELDS}),
INDEXES => [
priority_value_idx => {FIELDS => ['value'], TYPE => 'UNIQUE'},
- priority_sortkey_idx => ['sortkey', 'value'],
+ priority_sortkey_idx => ['sortkey', 'value'],
priority_visibility_value_id_idx => ['visibility_value_id'],
],
},
FIELDS => dclone(FIELD_TABLE_SCHEMA->{FIELDS}),
INDEXES => [
rep_platform_value_idx => {FIELDS => ['value'], TYPE => 'UNIQUE'},
- rep_platform_sortkey_idx => ['sortkey', 'value'],
+ rep_platform_sortkey_idx => ['sortkey', 'value'],
rep_platform_visibility_value_id_idx => ['visibility_value_id'],
],
},
FIELDS => dclone(FIELD_TABLE_SCHEMA->{FIELDS}),
INDEXES => [
op_sys_value_idx => {FIELDS => ['value'], TYPE => 'UNIQUE'},
- op_sys_sortkey_idx => ['sortkey', 'value'],
+ op_sys_sortkey_idx => ['sortkey', 'value'],
op_sys_visibility_value_id_idx => ['visibility_value_id'],
],
},
{TYPE => 'varchar(64)', NOTNULL => 1, DEFAULT => "'---'"}, FIELD_TYPE_TEXTAREA,
{TYPE => 'MEDIUMTEXT', NOTNULL => 1, DEFAULT => "''"}, FIELD_TYPE_DATETIME,
{TYPE => 'DATETIME'}, FIELD_TYPE_DATE, {TYPE => 'DATE'}, FIELD_TYPE_BUG_ID,
- {TYPE => 'INT3'}, FIELD_TYPE_INTEGER,
+ {TYPE => 'INT3'}, FIELD_TYPE_INTEGER,
{TYPE => 'INT4', NOTNULL => 1, DEFAULT => 0},
};
return 0 if $no_warn; # We don't want an error to be thrown; return.
trick_taint($name);
- my $field = new Bugzilla::Field({name => $name});
+ my $field = new Bugzilla::Field({name => $name});
my $field_desc = $field ? $field->description : $name;
ThrowCodeError('illegal_field', {field => $field_desc});
}
my ($params) = @_;
my $current = $params->{current};
my $total = $params->{total};
- my $every = $params->{every} || 1;
+ my $every = $params->{every} || 1;
print "." if !($current % $every);
if ($current == $total || $current % ($every * 60) == 0) {
$current_data{bug_when} = $self->parse_date($value);
}
if ($column eq 'Why') {
- $value = '' if !defined $value;
+ $value = '' if !defined $value;
$current_data{comment} = $value;
- $on_why = 1;
+ $on_why = 1;
}
else {
$on_why = 0;
my @values = $self->_param_array($param_name);
next if !@values;
my $default_op = $param_name eq 'content' ? 'matches' : 'anyexact';
- my $operator = $params->{"${param_name}_type"} || $default_op;
+ my $operator = $params->{"${param_name}_type"} || $default_op;
# Fields that are displayed as multi-selects are passed as arrays,
# so that they can properly search values that contain commas.
my @param_list = keys %$params;
my @all_field_params = grep {/^field-?\d+/} @param_list;
- my @chart_ids = map { /^field(-?\d+)/; $1 } @all_field_params;
+ my @chart_ids = map { /^field(-?\d+)/; $1 } @all_field_params;
@chart_ids = sort { $a <=> $b } uniq @chart_ids;
my $clause = new Bugzilla::Search::Clause();
foreach my $chart_id (@chart_ids) {
my @all_and = grep {/^field$chart_id-\d+/} @param_list;
- my @and_ids = map { /^field$chart_id-(\d+)/; $1 } @all_and;
+ my @and_ids = map { /^field$chart_id-(\d+)/; $1 } @all_and;
@and_ids = sort { $a <=> $b } uniq @and_ids;
my $and_clause = new Bugzilla::Search::Clause();
foreach my $and_id (@and_ids) {
my @all_or = grep {/^field$chart_id-$and_id-\d+/} @param_list;
- my @or_ids = map { /^field$chart_id-$and_id-(\d+)/; $1 } @all_or;
+ my @or_ids = map { /^field$chart_id-$and_id-(\d+)/; $1 } @all_or;
@or_ids = sort { $a <=> $b } uniq @or_ids;
my $or_clause = new Bugzilla::Search::Clause('OR');
my @param_list = keys %$params;
my @field_params = grep {/^f\d+$/} @param_list;
- my @field_ids = map { /(\d+)/; $1 } @field_params;
+ my @field_ids = map { /(\d+)/; $1 } @field_params;
@field_ids = sort { $a <=> $b } @field_ids;
return @field_ids;
}
if (ref $value eq 'ARRAY') {
# Trim input and ignore blank values.
- @$value = map { trim($_) } @$value;
+ @$value = map { trim($_) } @$value;
@$value = grep { defined $_ and $_ ne '' } @$value;
return if !@$value;
- $orig_value = join(',', @$value);
+ $orig_value = join(',', @$value);
$string_value = join(',', @$value);
}
else {
return if $value eq '';
- $orig_value = $value;
+ $orig_value = $value;
$string_value = $value;
}
= @$args{qw(field operator joins chart_id)};
my $dbh = Bugzilla->dbh;
$operator = $self->_reverse_operator($operator) if $not;
- $not = $operator eq 'isnotempty' ? 'NOT' : '';
+ $not = $operator eq 'isnotempty' ? 'NOT' : '';
if ($field eq 'keywords') {
push @$joins,
# Get all the fields whose names don't contain periods. (Fields that
# contain periods are always handled in MAPPINGS.)
my @db_fields = grep { $_->name !~ /\./ } @{Bugzilla->fields({obsolete => 0})};
- my %full_map = (%{MAPPINGS()}, map { $_->name => $_->name } @db_fields);
+ my %full_map = (%{MAPPINGS()}, map { $_->name => $_->name } @db_fields);
# Eliminate the fields that start with bug_ or rep_, because those are
# handled by the MAPPINGS instead, and we don't want too many names
# (both because it's unnecessary and because otherwise
# "reporter_accessible" and "reporter" both match "rep".
delete @full_map{qw(rep_platform bug_status bug_file_loc bug_group
- bug_severity bug_status
- status_whiteboard
- cclist_accessible reporter_accessible)};
+ bug_severity bug_status
+ status_whiteboard
+ cclist_accessible reporter_accessible)};
Bugzilla::Hook::process('quicksearch_map', {'map' => \%full_map});
# Get the hooks out of the cache if they exist. Otherwise, read them
# from the disk.
my $cache = Bugzilla->request_cache->{template_plugin_hook_cache} ||= {};
- my $lang = $context->{bz_language} || '';
+ my $lang = $context->{bz_language} || '';
$cache->{"${lang}__$extension_template"}
||= $self->_get_hooks($extension_template);
$vars->{'script_name'} = basename($0);
$vars->{'token'} = issue_hash_token($data);
$vars->{'reason'}
- = (!$token) ? 'missing_token'
+ = (!$token) ? 'missing_token'
: ($expected_token ne $token) ? 'invalid_token'
: 'expired_token';
print Bugzilla->cgi->header();
sub set_disabledtext {
$_[0]->set('disabledtext', $_[1]);
- $_[0]->set('is_enabled', $_[1] ? 0 : 1);
+ $_[0]->set('is_enabled', $_[1] ? 0 : 1);
}
sub set_groups {
# Go through the array, and turn items into group objects
my @groups = ();
foreach my $value (@{$changes->{$key}}) {
- my $type = $value =~ /^\d+$/ ? 'id' : 'name';
+ my $type = $value =~ /^\d+$/ ? 'id' : 'name';
my $group = Bugzilla::Group->new({$type => $value});
if (!$group || !$user->can_bless($group->id)) {
return [] unless $self->id;
# Exclude the user's own queries.
- my @my_query_ids = map($_->id, @{$self->queries});
+ my @my_query_ids = map($_->id, @{$self->queries});
my $query_id_string = join(',', @my_query_ids) || '-1';
# Only show subscriptions that we can still actually see. If a
return [] unless $self->id;
# Exclude the user's own queries.
- my @my_query_ids = map($_->id, @{$self->queries});
+ my @my_query_ids = map($_->id, @{$self->queries});
my $query_id_string = join(',', @my_query_ids) || '-1';
my $avail_query_ids = Bugzilla->dbh->selectcol_arrayref(
sub set_revoked { $_[0]->set('revoked', $_[1]); }
# Validators
-sub _check_api_key { return generate_random_password(40); }
+sub _check_api_key { return generate_random_password(40); }
sub _check_description { return trim($_[1]) || ''; }
1;
}
my %field_data = (
- id => $self->type('int', $field->id),
- type => $self->type('int', $field->type),
- is_custom => $self->type('boolean', $field->custom),
- name => $self->type('string', $field->name),
- display_name => $self->type('string', $field->description),
- is_mandatory => $self->type('boolean', $field->is_mandatory),
- is_on_bug_entry => $self->type('boolean', $field->enter_bug),
- visibility_field => $self->type('string', $visibility_field),
+ id => $self->type('int', $field->id),
+ type => $self->type('int', $field->type),
+ is_custom => $self->type('boolean', $field->custom),
+ name => $self->type('string', $field->name),
+ display_name => $self->type('string', $field->description),
+ is_mandatory => $self->type('boolean', $field->is_mandatory),
+ is_on_bug_entry => $self->type('boolean', $field->enter_bug),
+ visibility_field => $self->type('string', $visibility_field),
visibility_values => [map { $self->type('string', $_->name) } @$vis_values],
);
if ($has_values) {
my %options = (fields => ['bug_id']);
# Find the highest custom field id
- my @field_ids = grep(/^f(\d+)$/, keys %$match_params);
+ my @field_ids = grep(/^f(\d+)$/, keys %$match_params);
my $last_field_id = @field_ids ? max @field_ids + 1 : 1;
# Do special search types for certain fields.
return filter $params,
{
- id => $self->type('int', $classification->id),
- name => $self->type('string', $classification->name),
- description => $self->type('string', $classification->description),
- sort_key => $self->type('int', $classification->sortkey),
- products => [map { $self->_product_to_hash($_, $params) } @$products],
+ id => $self->type('int', $classification->id),
+ name => $self->type('string', $classification->name),
+ description => $self->type('string', $classification->description),
+ sort_key => $self->type('int', $classification->sortkey),
+ products => [map { $self->_product_to_hash($_, $params) } @$products],
};
}
my @fieldlist = (Bugzilla::Bug->fields, 'group', 'long_desc', 'attachment',
'attachmentdata');
my %displayfields = map { $_ => 1 } @fieldlist;
- my $vars = {bugs => [$export_me], displayfields => \%displayfields};
+ my $vars = {bugs => [$export_me], displayfields => \%displayfields};
$template->process("bug/show.xml.tmpl", $vars, \$msg)
|| ThrowTemplateError($template->error());
$msg .= "\n";
format_time($bug_fields{'delta_ts'}, "%Y-%m-%d %T") || $timestamp);
# Bug Access
- push(@query, "cclist_accessible");
+ push(@query, "cclist_accessible");
push(@values, $bug_fields{'cclist_accessible'} ? 1 : 0);
- push(@query, "reporter_accessible");
+ push(@query, "reporter_accessible");
push(@values, $bug_fields{'reporter_accessible'} ? 1 : 0);
my $product = new Bugzilla::Product({name => $bug_fields{'product'} || ''});
my $extra_values = $self->_extra_bug_create_values->{$number};
foreach my $field (qw(comments remaining_time percentage_complete
keyword_objects everconfirmed dependson blocked
- groups_in classification actual_time))
+ groups_in classification actual_time))
{
$extra_values->{$field} = $bug->$field;
}
search => 1,
db_skip => ['Pg'],
operator_ok => [qw(allwords allwordssubstr anywordssubstr casesubstring
- changedbefore changedafter greaterthan greaterthaneq
- lessthan lessthaneq notregexp notsubstring
- nowordssubstr regexp substring anywords
- notequals nowords equals anyexact)],
+ changedbefore changedafter greaterthan greaterthaneq
+ lessthan lessthaneq notregexp notsubstring
+ nowordssubstr regexp substring anywords
+ notequals nowords equals anyexact)],
},
};
contains => [1],
columns => ['assigned_to'],
params => [
- {f => 'bug_id', o => 'equals', v => '<1>'},
+ {f => 'bug_id', o => 'equals', v => '<1>'},
{f => 'OP'},
{f => 'CP'},
{f => 'assigned_to', o => 'substr', v => '@'},
params => [
{f => 'bug_id', o => 'equals', v => '<3>'},
{f => 'OP'},
- {f => 'OP', j => 'OR'},
- {f => 'bug_id', o => 'equals', v => '<1>'},
+ {f => 'OP', j => 'OR'},
+ {f => 'bug_id', o => 'equals', v => '<1>'},
{f => 'assigned_to', o => 'equals', v => '<2>'},
{f => 'CP'},
{f => 'OP', j => 'OR'},
params => [
{f => 'bug_id', o => 'equals', v => '<3>'},
{f => 'OP'},
- {f => 'OP', j => 'OR'},
- {f => 'bug_id', o => 'equals', v => '<1>'},
+ {f => 'OP', j => 'OR'},
+ {f => 'bug_id', o => 'equals', v => '<1>'},
{f => 'assigned_to', o => 'equals', v => '<2>'},
{f => 'CP'},
{f => 'OP', j => 'OR'},
}
# The tests we know are broken for this operator/field combination.
-sub _known_broken { return {} }
+sub _known_broken { return {} }
sub contains_known_broken { return undef }
sub search_known_broken { return undef }
sub field_not_yet_implemented { return undef }
projects / thirdparty / bugzilla.git / commitdiff
