From a2eca825a00b33912ec60f797d1112115772ec30 Mon Sep 17 00:00:00 2001 From: "mkanat%kerio.com" <> Date: Thu, 9 Mar 2006 08:08:57 +0000 Subject: Bug 328638: Remove @::legal_keywords and %::keywordsbyname Patch By Max Kanat-Alexander r=LpSolit, a=justdave --- Bugzilla/Bug.pm | 9 +- Bugzilla/Keyword.pm | 213 +++++++++++++++++++++++++++++++++++++++++ Bugzilla/Search.pm | 7 +- Bugzilla/Search/Quicksearch.pm | 3 +- 4 files changed, 221 insertions(+), 11 deletions(-) create mode 100644 Bugzilla/Keyword.pm (limited to 'Bugzilla') diff --git a/Bugzilla/Bug.pm b/Bugzilla/Bug.pm index 43f5a1285..c314b8ee1 100755 --- a/Bugzilla/Bug.pm +++ b/Bugzilla/Bug.pm @@ -30,7 +30,7 @@ package Bugzilla::Bug; use strict; -use vars qw($legal_keywords @legal_platform +use vars qw(@legal_platform @legal_priority @legal_severity @legal_opsys @legal_bug_status @settable_resolution %components %target_milestone @enterable_products %milestoneurl %prodmaxvotes); @@ -523,11 +523,6 @@ sub show_attachment_flags { return $self->{'show_attachment_flags'}; } - -sub use_keywords { - return @::legal_keywords; -} - sub use_votes { my ($self) = @_; return 0 if $self->{'error'}; @@ -1337,7 +1332,7 @@ sub _validate_attribute { longdescs milestoneurl attachments isopened isunconfirmed flag_types num_attachment_flag_types - show_attachment_flags use_keywords any_flags_requesteeble), + show_attachment_flags any_flags_requesteeble), # Bug fields. Bugzilla::Bug->fields diff --git a/Bugzilla/Keyword.pm b/Bugzilla/Keyword.pm new file mode 100644 index 000000000..b35827288 --- /dev/null +++ b/Bugzilla/Keyword.pm @@ -0,0 +1,213 @@ +# -*- 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 Original Code is the Bugzilla Bug Tracking System. +# +# Contributor(s): Max Kanat-Alexander + +use strict; + +package Bugzilla::Keyword; + +use Bugzilla::Util; +use Bugzilla::Error; + +############################### +#### Initialization #### +############################### + +use constant DB_COLUMNS => qw( + keyworddefs.id + keyworddefs.name + keyworddefs.description +); + +my $columns = join(", ", DB_COLUMNS); + +sub new { + my $invocant = shift; + my $class = ref($invocant) || $invocant; + my $self = {}; + bless($self, $class); + return $self->_init(@_); +} + +sub _init { + my $self = shift; + my ($param) = @_; + my $dbh = Bugzilla->dbh; + + my $id = $param unless (ref $param eq 'HASH'); + my $keyword; + + if (defined $id) { + detaint_natural($id) + || ThrowCodeError('param_must_be_numeric', + {function => 'Bugzilla::Keyword::_init'}); + + $keyword = $dbh->selectrow_hashref(qq{ + SELECT $columns FROM keyworddefs + WHERE id = ?}, undef, $id); + } elsif (defined $param->{'name'}) { + trick_taint($param->{'name'}); + $keyword = $dbh->selectrow_hashref(qq{ + SELECT $columns FROM keyworddefs + WHERE name = ?}, undef, $param->{'name'}); + } else { + ThrowCodeError('bad_arg', + {argument => 'param', + function => 'Bugzilla::Keyword::_init'}); + } + + return undef unless (defined $keyword); + + foreach my $field (keys %$keyword) { + $self->{$field} = $keyword->{$field}; + } + return $self; +} + +sub new_from_list { + my $class = shift; + my ($id_list) = @_; + my $dbh = Bugzilla->dbh; + + my $keywords; + if ($id_list) { + my @detainted_ids; + foreach my $id (@$id_list) { + detaint_natural($id) || + ThrowCodeError('param_must_be_numeric', + {function => 'Bugzilla::Keyword::new_from_list'}); + push(@detainted_ids, $id); + } + $keywords = $dbh->selectall_arrayref( + "SELECT $columns FROM keyworddefs WHERE id IN (" + . join(',', @detainted_ids) . ")", {Slice=>{}}) || []; + } else { + ThrowCodeError('bad_arg', + {argument => 'id_list', + function => 'Bugzilla::Keyword::new_from_list'}); + } + + foreach my $keyword (@$keywords) { + bless($keyword, $class); + } + return $keywords; +} + +############################### +#### Accessors ###### +############################### + +sub id { return $_[0]->{'id'}; } +sub name { return $_[0]->{'name'}; } +sub description { return $_[0]->{'description'}; } + +############################### +#### Subroutines ###### +############################### + +sub get_all_keywords { + my $dbh = Bugzilla->dbh; + + my $ids = $dbh->selectcol_arrayref(q{ + SELECT id FROM keyworddefs ORDER BY name}); + + my $keywords = Bugzilla::Keyword->new_from_list($ids); + return @$keywords; +} + +sub keyword_count { + my ($count) = + Bugzilla->dbh->selectrow_array('SELECT COUNT(*) FROM keyworddefs'); + return $count; +} + +1; + +__END__ + +=head1 NAME + +Bugzilla::Keyword - A Keyword that can be added to a bug. + +=head1 SYNOPSIS + + use Bugzilla::Keyword; + + my $keyword = new Bugzilla::Keyword(1); + my $keyword = new Bugzilla::Keyword({name => 'perf'}); + + my $id = $keyword->id; + my $name = $keyword->name; + my $description = $keyword->description; + +=head1 DESCRIPTION + +Bugzilla::Keyword represents a keyword that can be added to a bug. + +=head1 METHODS + +=over + +=item C + + Description: The constructor is used to load an existing keyword + by passing a keyword id or a hash. + + Params: $param - If you pass an integer, the integer is the + keyword id from the database that we want to + read in. If you pass in a hash with 'name' key, + then the value of the name key is the name of a + keyword from the DB. + + Returns: A Bugzilla::Keyword object. + +=item C + + Description: Creates an array of Keyword objects, given an + array of ids. + + Params: \@id_list - A reference to an array of numbers, keyword ids. + If any of these are not numeric, the function + will throw an error. If any of these are not + valid keyword ids, they will simply be skipped. + + Returns: A reference to an array of C objects. + +=back + +=head1 SUBROUTINES + +=over + +=item C + + Description: Returns all keywords from the database. + + Params: none. + + Returns: A list of C objects, + or an empty list if there are none. + +=item C + + Description: A utility function to get the total number + of keywords defined. Mostly used to see + if there are any keywords defined at all. + Params: none + Returns: An integer, the count of keywords. + +=back + +=cut diff --git a/Bugzilla/Search.pm b/Bugzilla/Search.pm index 0e1f7057d..181f49b19 100644 --- a/Bugzilla/Search.pm +++ b/Bugzilla/Search.pm @@ -42,6 +42,7 @@ use Bugzilla::Group; use Bugzilla::User; use Bugzilla::Field; use Bugzilla::Bug; +use Bugzilla::Keyword; use Date::Format; use Date::Parse; @@ -933,9 +934,9 @@ sub init { if ($value eq '') { next; } - my $id = &::GetKeywordIdFromName($value); - if ($id) { - push(@list, "$table.keywordid = $id"); + my $keyword = new Bugzilla::Keyword({name => $value}); + if ($keyword) { + push(@list, "$table.keywordid = " . $keyword->id); } else { ThrowUserError("unknown_keyword", diff --git a/Bugzilla/Search/Quicksearch.pm b/Bugzilla/Search/Quicksearch.pm index 4d9958c63..e4224b959 100644 --- a/Bugzilla/Search/Quicksearch.pm +++ b/Bugzilla/Search/Quicksearch.pm @@ -27,6 +27,7 @@ use Bugzilla; use Bugzilla::Config; use Bugzilla::Error; use Bugzilla::Constants; +use Bugzilla::Keyword; use Bugzilla::Bug; use base qw(Exporter); @@ -325,7 +326,7 @@ sub quicksearch { $word, $negate); } if (grep({lc($word) eq $_} - @::legal_keywords)) { + map($_->name, Bugzilla::Keyword::get_all_keywords()))) { addChart('keywords', 'substring', $word, $negate); if (length($word)>2) { -- cgit v1.2.3-24-g4f1b