enter_bug.cgi

#!/usr/bin/perl -T
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This Source Code Form is "Incompatible With Secondary Licenses", as
# defined by the Mozilla Public License, v. 2.0.

##############################################################################
#
# enter_bug.cgi
# -------------
# Displays bug entry form. Bug fields are specified through popup menus,
# drop-down lists, or text fields. Default for these values can be
# passed in as parameters to the cgi.
#
##############################################################################

use 5.14.0;
use strict;
use warnings;

use lib qw(. lib);

use Bugzilla;
use Bugzilla::Constants;
use Bugzilla::Util;
use Bugzilla::Error;
use Bugzilla::Bug;
use Bugzilla::Hook;
use Bugzilla::Classification;
use Bugzilla::Token;
use Bugzilla::Field;
use Bugzilla::Status;
use Bugzilla::UserAgent;

use List::MoreUtils qw(none);

my $user = Bugzilla->login(LOGIN_REQUIRED);

my $cloned_bug;
my $cloned_bug_id;

my $cgi      = Bugzilla->cgi;
my $dbh      = Bugzilla->dbh;
my $template = Bugzilla->template;
my $vars     = {};

# All pages point to the same part of the documentation.
$vars->{'doc_section'} = 'using/filing.html';

my $product_name = trim($cgi->param('product') || '');

# Will contain the product object the bug is created in.
my $product;

if ($product_name eq '') {

  # If the user cannot enter bugs in any product, stop here.
  my @enterable_products = @{$user->get_enterable_products};
  ThrowUserError('no_products') unless scalar(@enterable_products);

  my $classification
    = Bugzilla->params->{'useclassification'}
    ? scalar($cgi->param('classification'))
    : '__all';

  # Unless a real classification name is given, we sort products
  # by classification.
  my @classifications;

  unless ($classification && $classification ne '__all') {
    @classifications = @{sort_products_by_classification(\@enterable_products)};
  }

  unless ($classification) {

    # We know there is at least one classification available,
    # else we would have stopped earlier.
    if (scalar(@classifications) > 1) {

      # We only need classification objects.
      $vars->{'classifications'} = [map { $_->{'object'} } @classifications];

      $vars->{'target'} = "enter_bug.cgi";

      print $cgi->header();
      $template->process("global/choose-classification.html.tmpl", $vars)
        || ThrowTemplateError($template->error());
      exit;
    }

    # If we come here, then there is only one classification available.
    $classification = $classifications[0]->{'object'}->name;
  }

  # Keep only enterable products which are in the specified classification.
  if ($classification ne "__all") {
    my $class = new Bugzilla::Classification({'name' => $classification});

    # If the classification doesn't exist, then there is no product in it.
    if ($class) {
      @enterable_products
        = grep { $_->classification_id == $class->id } @enterable_products;
      @classifications = ({object => $class, products => \@enterable_products});
    }
    else {
      @enterable_products = ();
    }
  }

  if (scalar(@enterable_products) == 0) {
    ThrowUserError('no_products');
  }
  elsif (scalar(@enterable_products) > 1) {
    $vars->{'classifications'} = \@classifications;
    $vars->{'target'}          = "enter_bug.cgi";

    print $cgi->header();
    $template->process("global/choose-product.html.tmpl", $vars)
      || ThrowTemplateError($template->error());
    exit;
  }
  else {
    # Only one product exists.
    $product = $enterable_products[0];
  }
}

# We need to check and make sure that the user has permission
# to enter a bug against this product.
$product = $user->can_enter_product($product || $product_name, THROW_ERROR);

##############################################################################
# Useful Subroutines
##############################################################################
sub formvalue {
  my ($name, $default) = (@_);
  return Bugzilla->cgi->param($name) || $default || "";
}

##############################################################################
# End of subroutines
##############################################################################

my $has_editbugs   = $user->in_group('editbugs',   $product->id);
my $has_canconfirm = $user->in_group('canconfirm', $product->id);

# If a user is trying to clone a bug
#   Check that the user has authorization to view the parent bug
#   Create an instance of Bug that holds the info from the parent
$cloned_bug_id = $cgi->param('cloned_bug_id');

if ($cloned_bug_id) {
  $cloned_bug    = Bugzilla::Bug->check($cloned_bug_id);
  $cloned_bug_id = $cloned_bug->id;
}

# If there is only one active component, choose it
my @active = grep { $_->is_active } @{$product->components};
if (scalar(@active) == 1) {
  $cgi->param('component', $active[0]->name);
}

# If there is only one active version, choose it
@active = grep { $_->is_active } @{$product->versions};
if (scalar(@active) == 1) {
  $cgi->param('version', $active[0]->name);
}

my %default;

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

$vars->{'priority'}     = get_legal_field_values('priority');
$vars->{'bug_severity'} = get_legal_field_values('bug_severity');
$vars->{'rep_platform'} = get_legal_field_values('rep_platform');
$vars->{'op_sys'}       = get_legal_field_values('op_sys');

$vars->{'assigned_to'}          = formvalue('assigned_to');
$vars->{'assigned_to_disabled'} = !$has_editbugs;
$vars->{'cc_disabled'}          = 0;

$vars->{'qa_contact'}          = formvalue('qa_contact');
$vars->{'qa_contact_disabled'} = !$has_editbugs;

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

$vars->{'token'} = issue_session_token('create_bug');


my @enter_bug_fields = grep { $_->enter_bug } Bugzilla->active_custom_fields;
foreach my $field (@enter_bug_fields) {
  my $cf_name  = $field->name;
  my $cf_value = $cgi->param($cf_name);
  if (defined $cf_value) {
    if ($field->type == FIELD_TYPE_MULTI_SELECT) {
      $cf_value = [$cgi->param($cf_name)];
    }
    $default{$cf_name} = $vars->{$cf_name} = $cf_value;
  }
}

# This allows the Field visibility and value controls to work with the
# Classification and Product fields as a parent.
$default{'classification'} = $product->classification->name;
$default{'product'}        = $product->name;

if ($cloned_bug_id) {

  $default{'component_'}   = $cloned_bug->component;
  $default{'priority'}     = $cloned_bug->priority;
  $default{'bug_severity'} = $cloned_bug->bug_severity;
  $default{'rep_platform'} = $cloned_bug->rep_platform;
  $default{'op_sys'}       = $cloned_bug->op_sys;

  $vars->{'short_desc'}   = $cloned_bug->short_desc;
  $vars->{'bug_file_loc'} = $cloned_bug->bug_file_loc;
  $vars->{'keywords'}     = $cloned_bug->keywords;
  $vars->{'dependson'}    = join(", ", $cloned_bug_id, @{$cloned_bug->dependson});
  $vars->{'blocked'}      = join(", ", @{$cloned_bug->blocked});
  $vars->{'deadline'}     = $cloned_bug->deadline;
  $vars->{'estimated_time'} = $cloned_bug->estimated_time;

  if (scalar @{$cloned_bug->cc}) {
    $vars->{'cc'} = join(", ", @{$cloned_bug->cc});
  }
  else {
    $vars->{'cc'} = formvalue('cc');
  }

  foreach my $role (qw(reporter assigned_to qa_contact)) {
    if ( defined($cloned_bug->$role)
      && $cloned_bug->$role->id != $user->id
      && none { $_ eq $cloned_bug->$role->login } @{$cloned_bug->cc})
    {
      $vars->{'cc'} = join(", ", $cloned_bug->$role->login, $vars->{'cc'});
    }
  }

  foreach my $field (@enter_bug_fields) {
    my $field_name = $field->name;
    $vars->{$field_name} = $cloned_bug->$field_name;
  }

  # We need to ensure that we respect the 'insider' status of
  # the first comment, if it has one. Either way, make a note
  # that this bug was cloned from another bug.
  my $bug_desc  = $cloned_bug->comments({order => 'oldest_to_newest'})->[0];
  my $isprivate = $bug_desc->is_private;

  $vars->{'comment'}            = "";
  $vars->{'comment_is_private'} = 0;

  if (!$isprivate || $user->is_insider) {

    # We use "body" to avoid any format_comment text, which would be
    # pointless to clone.
    $vars->{'comment'}            = $bug_desc->body;
    $vars->{'comment_is_private'} = $isprivate;
  }

}    # end of cloned bug entry form

else {
  $default{'component_'} = formvalue('component');
  $default{'priority'}
    = formvalue('priority', Bugzilla->params->{'defaultpriority'});
  $default{'bug_severity'}
    = formvalue('bug_severity', Bugzilla->params->{'defaultseverity'});
  $default{'rep_platform'} = formvalue('rep_platform',
    Bugzilla->params->{'defaultplatform'} || detect_platform());
  $default{'op_sys'}
    = formvalue('op_sys', Bugzilla->params->{'defaultopsys'} || detect_op_sys());

  $vars->{'alias'}          = formvalue('alias');
  $vars->{'short_desc'}     = formvalue('short_desc');
  $vars->{'bug_file_loc'}   = formvalue('bug_file_loc', "http://");
  $vars->{'keywords'}       = formvalue('keywords');
  $vars->{'dependson'}      = formvalue('dependson');
  $vars->{'blocked'}        = formvalue('blocked');
  $vars->{'deadline'}       = formvalue('deadline');
  $vars->{'estimated_time'} = formvalue('estimated_time');
  $vars->{'see_also'}       = formvalue('see_also');

  $vars->{'cc'} = join(', ', $cgi->param('cc'));

  $vars->{'comment'}            = formvalue('comment');
  $vars->{'comment_is_private'} = formvalue('comment_is_private');

}    # end of normal/bookmarked entry form


# IF this is a cloned bug,
# AND the clone's product is the same as the parent's
#   THEN use the version from the parent bug
# ELSE IF a version is supplied in the URL
#   THEN use it
# ELSE IF there is a version in the cookie
#   THEN use it (Posting a bug sets a cookie for the current version.)
# ELSE
#   The default version is the last one in the list (which, it is
#   hoped, will be the most recent one).
#
# Eventually maybe each product should have a "current version"
# parameter.
$vars->{'version'} = $product->versions;

my $version_cookie = $cgi->cookie("VERSION-" . $product->name);

if (($cloned_bug_id) && ($product->name eq $cloned_bug->product)) {
  $default{'version'} = $cloned_bug->version;
}
elsif (formvalue('version')) {
  $default{'version'} = formvalue('version');
}
elsif (defined $version_cookie
  and grep { $_->name eq $version_cookie } @{$vars->{'version'}})
{
  $default{'version'} = $version_cookie;
}
else {
  $default{'version'} = $vars->{'version'}->[$#{$vars->{'version'}}]->name;
}

# Get list of milestones.
if (Bugzilla->params->{'usetargetmilestone'}) {
  $vars->{'target_milestone'} = $product->milestones;
  if (formvalue('target_milestone')) {
    $default{'target_milestone'} = formvalue('target_milestone');
  }
  else {
    $default{'target_milestone'} = $product->default_milestone;
  }
}

# Construct the list of allowable statuses.
my @statuses = @{Bugzilla::Bug->new_bug_statuses($product)};

# Exclude closed states from the UI, even if the workflow allows them.
# The back-end code will still accept them, though.
# XXX We should remove this when the UI accepts closed statuses and update
# Bugzilla::Bug->default_bug_status.
@statuses = grep { $_->is_open } @statuses;

scalar(@statuses) || ThrowUserError('no_initial_bug_status');

$vars->{'bug_status'} = \@statuses;

# Get the default from a template value if it is legitimate.
# Otherwise, and only if the user has privs, set the default
# to the first confirmed bug status on the list, if available.

my $picked_status = formvalue('bug_status');
if ($picked_status and grep($_->name eq $picked_status, @statuses)) {
  $default{'bug_status'} = formvalue('bug_status');
}
else {
  $default{'bug_status'} = Bugzilla::Bug->default_bug_status(@statuses);
}

my @groups = $cgi->param('groups');
if ($cloned_bug) {
  my @clone_groups = map { $_->name } @{$cloned_bug->groups_in};

  # It doesn't matter if there are duplicate names, since all we check
  # for in the template is whether or not the group is set.
  push(@groups, @clone_groups);
}
$default{'groups'} = \@groups;

Bugzilla::Hook::process('enter_bug_entrydefaultvars', {vars => $vars});

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

my $format = $template->get_format(
  "bug/create/create",
  scalar $cgi->param('format'),
  scalar $cgi->param('ctype')
);

print $cgi->header($format->{'ctype'});
$template->process($format->{'template'}, $vars)
  || ThrowTemplateError($template->error());