use 5.14.0;

use strict;

use warnings;

use lib qw(. lib local/lib/perl5);

use Bugzilla;

use Bugzilla::Bug;

use Bugzilla::Constants;

use Bugzilla::Search;

use Bugzilla::Search::Saved;

use Bugzilla::User;

use Bugzilla::Util;

use Bugzilla::Error;

use Bugzilla::Product;

use Bugzilla::Version;

use Bugzilla::Keyword;

use Bugzilla::Field;

use Bugzilla::Token;

sub get_product_values {

my ($products, $field, $vars) = @_;

my @all_values = map { @{ $_->$field } } @$products;

my (@unique, %duplicates, %duplicate_count, %seen);

foreach my $value (@all_values) {

my $lc_name = lc($value->name);

if ($seen{$lc_name}) {

$duplicate_count{$seen{$lc_name}->id}++;

$duplicates{$value->id} = $seen{$lc_name};

next;

}

push(@unique, $value);

$seen{$lc_name} = $value;

}

$field =~ s/s$//;

if ($field eq 'version') {

@unique = sort { vers_cmp(lc($a->name), lc($b->name)) } @unique;

}

else {

@unique = sort { lc($a->name) cmp lc($b->name) } @unique;

}

$field = 'target_milestone' if $field eq 'milestone';

$vars->{duplicates}->{$field} = \%duplicates;

$vars->{duplicate_count}->{$field} = \%duplicate_count;

# "component" is a reserved word in Template Toolkit.

$field = 'component_' if $field eq 'component';

$vars->{$field} = \@unique;

}

my $cgi = Bugzilla->cgi;

my $dbh = Bugzilla->dbh;

my $template = Bugzilla->template;

my $vars = {};

my $buffer = $cgi->query_string();

my $user = Bugzilla->login();

my $userid = $user->id;

if ($cgi->param('nukedefaultquery')) {

if ($userid) {

my $token = $cgi->param('token');

check_hash_token($token, ['nukedefaultquery']);

my $named_queries = Bugzilla::Search::Saved->match(

{ userid => $userid, name => DEFAULT_QUERY_NAME });

if (@$named_queries) {

$named_queries->[0]->remove_from_db();

}

}

$buffer = "";

}

$dbh = Bugzilla->switch_to_shadow_db;

my $userdefaultquery;

if ($userid) {

$userdefaultquery = $dbh->selectrow_array(

"SELECT query FROM namedqueries " .

"WHERE userid = ? AND name = ?",

undef, ($userid, DEFAULT_QUERY_NAME));

}

local our %default;

sub PrefillForm {

my ($buf) = @_;

my $cgi = Bugzilla->cgi;

$buf = new Bugzilla::CGI($buf);

my $foundone = 0;

# If there are old-style boolean charts in the URL (from an old saved

# search or from an old link on the web somewhere) then convert them

# to the new "custom search" format so that the form is populated

# properly.

my $any_boolean_charts = grep { /^field-?\d+/ } $buf->multi_param();

if ($any_boolean_charts) {

my $search = new Bugzilla::Search(params => scalar $buf->Vars);

$search->boolean_charts_to_custom_search($buf);

}

# Query parameters that don't represent form fields on this page.

my @skip = qw(format query_format list_id columnlist);

# Iterate over the URL parameters

foreach my $name ($buf->multi_param()) {

next if grep { $_ eq $name } @skip;

$foundone = 1;

my @values = $buf->multi_param($name);

# If the name is a single letter followed by numbers, it's part

# of Custom Search. We store these as an array of hashes.

if ($name =~ /^([[:lower:]])(\d+)$/) {

$default{'custom_search'}->[$2]->{$1} = $values[0];

}

# If the name ends in a number (which it does for the fields which

# are part of the email searching), we use the array

# positions to show the defaults for that number field.

elsif ($name =~ /^(\w+)(\d)$/) {

$default{$1}->[$2] = $values[0];

}

else {

push (@{ $default{$name} }, @values);

}

}

return $foundone;

}

if (!PrefillForm($buffer)) {

# Ah-hah, there was no form stuff specified. Do it again with the

# default query.

if ($userdefaultquery) {

PrefillForm($userdefaultquery);

} else {

PrefillForm(Bugzilla->params->{"defaultquery"});

}

}

my @selectable_products = sort {lc($a->name) cmp lc($b->name)}

@{$user->get_selectable_products};

Bugzilla::Product::preload(\@selectable_products);

$vars->{'product'} = \@selectable_products;

foreach my $field (qw(components versions milestones)) {

get_product_values(\@selectable_products, $field, $vars);

}

if (Bugzilla->params->{'useclassification'}) {

$vars->{'classification'} = $user->get_selectable_classifications;

}

my @chfields;

push @chfields, "[Bug creation]";

foreach my $val (editable_bug_fields()) {

if ($val eq 'classification_id') {

$val = 'classification';

} elsif ($val eq 'product_id') {

$val = 'product';

} elsif ($val eq 'component_id') {

$val = 'component';

}

push @chfields, $val;

}

if ($user->is_timetracker) {

push @chfields, "work_time";

} else {

foreach my $tt_field (TIMETRACKING_FIELDS) {

@chfields = grep($_ ne $tt_field, @chfields);

}

}

@chfields = (sort(@chfields));

$vars->{'chfield'} = \@chfields;

$vars->{'bug_status'} = Bugzilla::Field->new({name => 'bug_status'})->legal_values;

$vars->{'rep_platform'} = Bugzilla::Field->new({name => 'rep_platform'})->legal_values;

$vars->{'op_sys'} = Bugzilla::Field->new({name => 'op_sys'})->legal_values;

$vars->{'priority'} = Bugzilla::Field->new({name => 'priority'})->legal_values;

$vars->{'bug_severity'} = Bugzilla::Field->new({name => 'bug_severity'})->legal_values;

$vars->{'resolution'} = Bugzilla::Field->new({name => 'resolution'})->legal_values;

my @custom_fields = Bugzilla->active_custom_fields;

$vars->{'custom_fields'} = \@custom_fields;

foreach my $cf (@custom_fields) {

if ($cf->type == FIELD_TYPE_SINGLE_SELECT || $cf->type == FIELD_TYPE_MULTI_SELECT) {

$vars->{$cf->name} = $cf->legal_values;

}

}

my @fields = @{ Bugzilla->fields({ obsolete => 0 }) };

my %exclude_fields = ();

if (!$user->is_timetracker) {

foreach my $tt_field (TIMETRACKING_FIELDS) {

$exclude_fields{$tt_field} = 1;

}

}

my %param_controlled_fields = ('useqacontact' => 'qa_contact',

'usetargetmilestone' => 'target_milestone',

'useclassification' => 'classification',

'usestatuswhiteboard' => 'status_whiteboard');

while (my ($param, $field) = each %param_controlled_fields) {

$exclude_fields{$field} = 1 unless Bugzilla->params->{$param};

}

@fields = grep(!$exclude_fields{$_->name}, @fields);

@fields = sort {lc($a->description) cmp lc($b->description)} @fields;

unshift(@fields, { name => "noop", description => "---" });

$vars->{'fields'} = \@fields;

if ($userid) {

$vars->{'namedqueries'} = $dbh->selectcol_arrayref(

"SELECT name FROM namedqueries " .

"WHERE userid = ? AND name != ? " .

"ORDER BY name",

undef, ($userid, DEFAULT_QUERY_NAME));

}

my $deforder;

my @orders = ('Bug Number', 'Importance', 'Assignee', 'Last Changed');

if ($cgi->cookie('LASTORDER')) {

$deforder = "Reuse same sort as last time";

unshift(@orders, $deforder);

}

if ($cgi->param('order')) { $deforder = $cgi->param('order') }

$vars->{'userdefaultquery'} = $userdefaultquery;

$vars->{'orders'} = \@orders;

$default{'order'} = [$deforder || 'Importance'];

if (($cgi->param('query_format') || $cgi->param('format') || "")

eq "create-series") {

require Bugzilla::Chart;

$vars->{'category'} = Bugzilla::Chart::getVisibleSeries();

}

$vars->{'known_name'} = $cgi->param('known_name');

$vars->{'columnlist'} = $cgi->param('columnlist');

$vars->{'default'} = \%default;

$vars->{'format'} = $cgi->param('format');

$vars->{'query_format'} = $cgi->param('query_format');

if (!($cgi->param('query_format') || $cgi->param('format'))) {

if (defined $cgi->cookie('DEFAULTFORMAT')) {

$vars->{'format'} = $cgi->cookie('DEFAULTFORMAT');

} else {

$vars->{'format'} = 'specific';

}

}

if (defined($vars->{'format'}) && IsValidQueryType($vars->{'format'})) {

$cgi->send_cookie(-name => 'DEFAULTFORMAT',

-value => $vars->{'format'},

-expires => "Fri, 01-Jan-2038 00:00:00 GMT");

}

my $format = $template->get_format("search/search",

$vars->{'query_format'} || $vars->{'format'},

scalar $cgi->param('ctype'));

Bugzilla::Hook::process("query_format", {'vars' => $vars, 'format' => $format});

print $cgi->header($format->{'ctype'});

$template->process($format->{'template'}, $vars)

|| ThrowTemplateError($template->error());