2003-03-27 03:07:02 +03:00
|
|
|
#!/usr/bin/perl -wT
|
1998-09-16 01:49:26 +04:00
|
|
|
# -*- Mode: perl; indent-tabs-mode: nil -*-
|
1998-08-26 10:14:20 +04:00
|
|
|
#
|
1999-11-02 02:33:56 +03:00
|
|
|
# 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.
|
|
|
|
#
|
1998-08-26 10:14:20 +04:00
|
|
|
# The Original Code is the Bugzilla Bug Tracking System.
|
2000-01-15 01:35:49 +03:00
|
|
|
#
|
1998-08-26 10:14:20 +04:00
|
|
|
# The Initial Developer of the Original Code is Netscape Communications
|
2000-01-15 01:35:49 +03:00
|
|
|
# Corporation. Portions created by Netscape are Copyright (C) 1998
|
|
|
|
# Netscape Communications Corporation. All Rights Reserved.
|
|
|
|
#
|
1998-08-26 10:14:20 +04:00
|
|
|
# Contributor(s): Terry Weissman <terry@mozilla.org>
|
2001-04-17 06:26:16 +04:00
|
|
|
# Dave Miller <justdave@syndicomm.com>
|
2000-03-10 19:25:03 +03:00
|
|
|
# Joe Robins <jmrobins@tgix.com>
|
2002-02-05 00:17:17 +03:00
|
|
|
# Gervase Markham <gerv@gerv.net>
|
2005-01-31 22:15:55 +03:00
|
|
|
# Shane H. W. Travis <travis@sedsystems.ca>
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2002-02-05 00:17:17 +03:00
|
|
|
##############################################################################
|
2000-01-15 01:35:49 +03:00
|
|
|
#
|
|
|
|
# enter_bug.cgi
|
|
|
|
# -------------
|
|
|
|
# Displays bug entry form. Bug fields are specified through popup menus,
|
2002-02-05 00:17:17 +03:00
|
|
|
# drop-down lists, or text fields. Default for these values can be
|
|
|
|
# passed in as parameters to the cgi.
|
2000-01-15 01:35:49 +03:00
|
|
|
#
|
2002-02-05 00:17:17 +03:00
|
|
|
##############################################################################
|
2000-01-15 01:35:49 +03:00
|
|
|
|
1998-09-16 01:49:26 +04:00
|
|
|
use strict;
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2002-01-20 04:44:52 +03:00
|
|
|
use lib qw(.);
|
|
|
|
|
2003-05-05 05:15:38 +04:00
|
|
|
use Bugzilla;
|
2002-11-24 22:56:34 +03:00
|
|
|
use Bugzilla::Constants;
|
2005-01-31 22:15:55 +03:00
|
|
|
use Bugzilla::Bug;
|
2005-03-16 01:10:14 +03:00
|
|
|
use Bugzilla::User;
|
1998-09-16 01:49:26 +04:00
|
|
|
require "CGI.pl";
|
1998-08-27 18:56:19 +04:00
|
|
|
|
2002-02-05 00:17:17 +03:00
|
|
|
use vars qw(
|
|
|
|
$template
|
|
|
|
$vars
|
2002-02-14 04:25:25 +03:00
|
|
|
@enterable_products
|
2002-02-05 00:17:17 +03:00
|
|
|
@legal_opsys
|
|
|
|
@legal_platform
|
|
|
|
@legal_priority
|
|
|
|
@legal_severity
|
2003-02-28 01:45:02 +03:00
|
|
|
@legal_keywords
|
2002-09-22 21:15:13 +04:00
|
|
|
$userid
|
2002-02-14 04:25:25 +03:00
|
|
|
%versions
|
2005-02-16 00:51:12 +03:00
|
|
|
%target_milestone
|
2002-11-24 22:56:34 +03:00
|
|
|
$proddesc
|
2004-08-21 01:49:20 +04:00
|
|
|
$classdesc
|
2002-02-05 00:17:17 +03:00
|
|
|
);
|
|
|
|
|
|
|
|
# If we're using bug groups to restrict bug entry, we need to know who the
|
|
|
|
# user is right from the start.
|
2004-03-27 06:51:44 +03:00
|
|
|
Bugzilla->login(LOGIN_REQUIRED) if AnyEntryGroups();
|
1998-09-16 01:49:26 +04:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
my $cloned_bug;
|
|
|
|
my $cloned_bug_id;
|
|
|
|
|
2003-05-05 05:15:38 +04:00
|
|
|
my $cgi = Bugzilla->cgi;
|
|
|
|
|
2004-04-07 07:38:26 +04:00
|
|
|
my $product = $cgi->param('product');
|
|
|
|
|
|
|
|
if (!defined $product) {
|
1998-09-16 01:49:26 +04:00
|
|
|
GetVersionTable();
|
2004-03-27 06:51:44 +03:00
|
|
|
Bugzilla->login();
|
2002-02-05 00:17:17 +03:00
|
|
|
|
2004-08-21 01:49:20 +04:00
|
|
|
if ( ! Param('useclassification') ) {
|
|
|
|
# just pick the default one
|
2005-03-16 02:59:46 +03:00
|
|
|
$cgi->param(-name => 'classification', -value => (keys %::classdesc)[0]);
|
2004-08-21 01:49:20 +04:00
|
|
|
}
|
|
|
|
|
2005-03-16 02:59:46 +03:00
|
|
|
if (!$cgi->param('classification')) {
|
2004-08-21 01:49:20 +04:00
|
|
|
my %classdesc;
|
|
|
|
my %classifications;
|
|
|
|
|
|
|
|
foreach my $c (GetSelectableClassifications()) {
|
|
|
|
$classdesc{$c} = $::classdesc{$c};
|
|
|
|
$classifications{$c} = $::classifications{$c};
|
|
|
|
}
|
|
|
|
|
|
|
|
my $classification_size = scalar(keys %classdesc);
|
|
|
|
if ($classification_size == 0) {
|
|
|
|
ThrowUserError("no_products");
|
|
|
|
}
|
|
|
|
elsif ($classification_size > 1) {
|
|
|
|
$vars->{'classdesc'} = \%classdesc;
|
|
|
|
$vars->{'classifications'} = \%classifications;
|
|
|
|
|
|
|
|
$vars->{'target'} = "enter_bug.cgi";
|
2005-03-16 02:59:46 +03:00
|
|
|
$vars->{'format'} = $cgi->param('format');
|
2004-08-21 01:49:20 +04:00
|
|
|
|
2005-02-25 18:40:20 +03:00
|
|
|
$vars->{'cloned_bug_id'} = $cgi->param('cloned_bug_id');
|
|
|
|
|
2005-03-17 18:14:58 +03:00
|
|
|
print $cgi->header();
|
2004-08-21 01:49:20 +04:00
|
|
|
$template->process("global/choose-classification.html.tmpl", $vars)
|
|
|
|
|| ThrowTemplateError($template->error());
|
|
|
|
exit;
|
|
|
|
}
|
2005-03-16 02:59:46 +03:00
|
|
|
$cgi->param(-name => 'classification', -value => (keys %classdesc)[0]);
|
2004-08-21 01:49:20 +04:00
|
|
|
}
|
2002-02-14 04:25:25 +03:00
|
|
|
|
2004-08-21 01:49:20 +04:00
|
|
|
my %products;
|
2002-02-14 04:25:25 +03:00
|
|
|
foreach my $p (@enterable_products) {
|
2004-08-21 01:49:20 +04:00
|
|
|
if (CanEnterProduct($p)) {
|
2005-03-16 02:59:46 +03:00
|
|
|
if (IsInClassification(scalar $cgi->param('classification'),$p) ||
|
|
|
|
$cgi->param('classification') eq "__all") {
|
2004-08-21 01:49:20 +04:00
|
|
|
$products{$p} = $::proddesc{$p};
|
|
|
|
}
|
2000-03-10 19:25:03 +03:00
|
|
|
}
|
2000-02-25 21:55:41 +03:00
|
|
|
}
|
2002-02-05 00:17:17 +03:00
|
|
|
|
2002-02-14 04:25:25 +03:00
|
|
|
my $prodsize = scalar(keys %products);
|
2002-02-05 00:17:17 +03:00
|
|
|
if ($prodsize == 0) {
|
2002-10-02 02:41:09 +04:00
|
|
|
ThrowUserError("no_products");
|
2002-02-05 00:17:17 +03:00
|
|
|
}
|
|
|
|
elsif ($prodsize > 1) {
|
2004-08-21 01:49:20 +04:00
|
|
|
my %classifications;
|
|
|
|
if ( ! Param('useclassification') ) {
|
|
|
|
@{$classifications{"all"}} = keys %products;
|
|
|
|
}
|
2005-03-16 02:59:46 +03:00
|
|
|
elsif ($cgi->param('classification') eq "__all") {
|
2004-08-21 01:49:20 +04:00
|
|
|
%classifications = %::classifications;
|
|
|
|
} else {
|
2005-03-16 02:59:46 +03:00
|
|
|
$classifications{$cgi->param('classification')} =
|
|
|
|
$::classifications{$cgi->param('classification')};
|
2004-08-21 01:49:20 +04:00
|
|
|
}
|
2002-02-14 04:25:25 +03:00
|
|
|
$vars->{'proddesc'} = \%products;
|
2004-08-21 01:49:20 +04:00
|
|
|
$vars->{'classifications'} = \%classifications;
|
|
|
|
$vars->{'classdesc'} = \%::classdesc;
|
2002-02-05 00:17:17 +03:00
|
|
|
|
|
|
|
$vars->{'target'} = "enter_bug.cgi";
|
2004-04-07 07:38:26 +04:00
|
|
|
$vars->{'format'} = $cgi->param('format');
|
2005-01-31 22:15:55 +03:00
|
|
|
|
|
|
|
$vars->{'cloned_bug_id'} = $cgi->param('cloned_bug_id');
|
2001-06-15 00:00:03 +04:00
|
|
|
|
2003-05-05 05:15:38 +04:00
|
|
|
print $cgi->header();
|
2002-04-24 11:24:50 +04:00
|
|
|
$template->process("global/choose-product.html.tmpl", $vars)
|
|
|
|
|| ThrowTemplateError($template->error());
|
2002-02-05 00:17:17 +03:00
|
|
|
exit;
|
2004-04-07 07:38:26 +04:00
|
|
|
} else {
|
|
|
|
# Only one product exists
|
|
|
|
$product = (keys %products)[0];
|
1998-08-27 18:56:19 +04:00
|
|
|
}
|
2002-02-05 00:17:17 +03:00
|
|
|
}
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2002-02-05 00:17:17 +03:00
|
|
|
##############################################################################
|
|
|
|
# Useful Subroutines
|
|
|
|
##############################################################################
|
1998-09-16 01:49:26 +04:00
|
|
|
sub formvalue {
|
|
|
|
my ($name, $default) = (@_);
|
2004-04-07 07:38:26 +04:00
|
|
|
return $cgi->param($name) || $default || "";
|
1998-09-16 01:49:26 +04:00
|
|
|
}
|
1998-08-26 10:14:20 +04:00
|
|
|
|
1998-09-16 01:49:26 +04:00
|
|
|
sub pickplatform {
|
2002-02-05 00:17:17 +03:00
|
|
|
return formvalue("rep_platform") if formvalue("rep_platform");
|
|
|
|
|
2004-08-28 12:58:14 +04:00
|
|
|
if (Param('defaultplatform')) {
|
|
|
|
return Param('defaultplatform');
|
|
|
|
} else {
|
1999-05-06 02:06:49 +04:00
|
|
|
for ($ENV{'HTTP_USER_AGENT'}) {
|
2001-11-05 07:44:34 +03:00
|
|
|
#PowerPC
|
|
|
|
/\(.*PowerPC.*\)/i && do {return "Macintosh";};
|
|
|
|
/\(.*PPC.*\)/ && do {return "Macintosh";};
|
|
|
|
/\(.*AIX.*\)/ && do {return "Macintosh";};
|
|
|
|
#Intel x86
|
|
|
|
/\(.*[ix0-9]86.*\)/ && do {return "PC";};
|
|
|
|
#Versions of Windows that only run on Intel x86
|
2004-03-22 04:48:50 +03:00
|
|
|
/\(.*Win(?:dows )[39M].*\)/ && do {return "PC";};
|
|
|
|
/\(.*Win(?:dows )16.*\)/ && do {return "PC";};
|
2001-11-05 07:44:34 +03:00
|
|
|
#Sparc
|
|
|
|
/\(.*sparc.*\)/ && do {return "Sun";};
|
|
|
|
/\(.*sun4.*\)/ && do {return "Sun";};
|
|
|
|
#Alpha
|
2004-03-22 04:48:50 +03:00
|
|
|
/\(.*AXP.*\)/i && do {return "DEC";};
|
|
|
|
/\(.*[ _]Alpha.\D/i && do {return "DEC";};
|
|
|
|
/\(.*[ _]Alpha\)/i && do {return "DEC";};
|
2001-11-05 07:44:34 +03:00
|
|
|
#MIPS
|
|
|
|
/\(.*IRIX.*\)/i && do {return "SGI";};
|
|
|
|
/\(.*MIPS.*\)/i && do {return "SGI";};
|
|
|
|
#68k
|
|
|
|
/\(.*68K.*\)/ && do {return "Macintosh";};
|
|
|
|
/\(.*680[x0]0.*\)/ && do {return "Macintosh";};
|
2004-03-22 04:48:50 +03:00
|
|
|
#HP
|
|
|
|
/\(.*9000.*\)/ && do {return "HP";};
|
2001-11-05 07:44:34 +03:00
|
|
|
#ARM
|
|
|
|
# /\(.*ARM.*\) && do {return "ARM";};
|
|
|
|
#Stereotypical and broken
|
|
|
|
/\(.*Macintosh.*\)/ && do {return "Macintosh";};
|
|
|
|
/\(.*Mac OS [89].*\)/ && do {return "Macintosh";};
|
|
|
|
/\(Win.*\)/ && do {return "PC";};
|
2004-03-22 04:48:50 +03:00
|
|
|
/\(.*Win(?:dows[ -])NT.*\)/ && do {return "PC";};
|
2001-11-05 07:44:34 +03:00
|
|
|
/\(.*OSF.*\)/ && do {return "DEC";};
|
|
|
|
/\(.*HP-?UX.*\)/i && do {return "HP";};
|
|
|
|
/\(.*IRIX.*\)/i && do {return "SGI";};
|
|
|
|
/\(.*(SunOS|Solaris).*\)/ && do {return "Sun";};
|
|
|
|
#Braindead old browsers who didn't follow convention:
|
|
|
|
/Amiga/ && do {return "Macintosh";};
|
2004-03-22 04:48:50 +03:00
|
|
|
/WinMosaic/ && do {return "PC";};
|
1999-05-06 02:05:19 +04:00
|
|
|
}
|
2004-08-28 12:58:14 +04:00
|
|
|
return "Other";
|
1998-08-26 10:14:20 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
1998-09-16 01:49:26 +04:00
|
|
|
sub pickos {
|
|
|
|
if (formvalue('op_sys') ne "") {
|
|
|
|
return formvalue('op_sys');
|
1998-08-26 10:14:20 +04:00
|
|
|
}
|
2004-08-28 12:58:14 +04:00
|
|
|
if (Param('defaultopsys')) {
|
|
|
|
return Param('defaultopsys');
|
|
|
|
} else {
|
1999-05-06 02:05:19 +04:00
|
|
|
for ($ENV{'HTTP_USER_AGENT'}) {
|
2001-11-05 07:44:34 +03:00
|
|
|
/\(.*IRIX.*\)/ && do {return "IRIX";};
|
|
|
|
/\(.*OSF.*\)/ && do {return "OSF/1";};
|
|
|
|
/\(.*Linux.*\)/ && do {return "Linux";};
|
2004-06-22 11:49:15 +04:00
|
|
|
/\(.*Solaris.*\)/ && do {return "Solaris";};
|
2001-11-05 07:44:34 +03:00
|
|
|
/\(.*SunOS 5.*\)/ && do {return "Solaris";};
|
2004-06-22 11:46:48 +04:00
|
|
|
/\(.*SunOS.*sun4u.*\)/ && do {return "Solaris";};
|
2001-11-05 07:44:34 +03:00
|
|
|
/\(.*SunOS.*\)/ && do {return "SunOS";};
|
|
|
|
/\(.*HP-?UX.*\)/ && do {return "HP-UX";};
|
2004-03-22 04:48:50 +03:00
|
|
|
/\(.*BSD\/(?:OS|386).*\)/ && do {return "BSDI";};
|
2001-11-05 07:44:34 +03:00
|
|
|
/\(.*FreeBSD.*\)/ && do {return "FreeBSD";};
|
|
|
|
/\(.*OpenBSD.*\)/ && do {return "OpenBSD";};
|
|
|
|
/\(.*NetBSD.*\)/ && do {return "NetBSD";};
|
|
|
|
/\(.*BeOS.*\)/ && do {return "BeOS";};
|
|
|
|
/\(.*AIX.*\)/ && do {return "AIX";};
|
2003-03-06 21:13:26 +03:00
|
|
|
/\(.*OS\/2.*\)/ && do {return "OS/2";};
|
2001-11-05 07:44:34 +03:00
|
|
|
/\(.*QNX.*\)/ && do {return "Neutrino";};
|
|
|
|
/\(.*VMS.*\)/ && do {return "OpenVMS";};
|
2002-04-15 07:54:18 +04:00
|
|
|
/\(.*Windows XP.*\)/ && do {return "Windows XP";};
|
2003-09-11 07:54:12 +04:00
|
|
|
/\(.*Windows NT 5\.2.*\)/ && do {return "Windows Server 2003";};
|
2002-04-15 07:54:18 +04:00
|
|
|
/\(.*Windows NT 5\.1.*\)/ && do {return "Windows XP";};
|
2001-11-05 07:44:34 +03:00
|
|
|
/\(.*Windows 2000.*\)/ && do {return "Windows 2000";};
|
2002-04-15 07:54:18 +04:00
|
|
|
/\(.*Windows NT 5.*\)/ && do {return "Windows 2000";};
|
2003-01-06 11:39:16 +03:00
|
|
|
/\(.*Win.*9[8x].*4\.9.*\)/ && do {return "Windows ME";};
|
2004-03-22 04:48:50 +03:00
|
|
|
/\(.*Win(?:dows )M[Ee].*\)/ && do {return "Windows ME";};
|
|
|
|
/\(.*Win(?:dows )98.*\)/ && do {return "Windows 98";};
|
|
|
|
/\(.*Win(?:dows )95.*\)/ && do {return "Windows 95";};
|
|
|
|
/\(.*Win(?:dows )16.*\)/ && do {return "Windows 3.1";};
|
|
|
|
/\(.*Win(?:dows[ -])NT.*\)/ && do {return "Windows NT";};
|
|
|
|
/\(.*Windows.*NT.*\)/ && do {return "Windows NT";};
|
2001-11-05 07:44:34 +03:00
|
|
|
/\(.*32bit.*\)/ && do {return "Windows 95";};
|
|
|
|
/\(.*16bit.*\)/ && do {return "Windows 3.1";};
|
|
|
|
/\(.*Mac OS 9.*\)/ && do {return "Mac System 9.x";};
|
|
|
|
/\(.*Mac OS 8\.6.*\)/ && do {return "Mac System 8.6";};
|
2001-11-09 08:32:43 +03:00
|
|
|
/\(.*Mac OS 8\.5.*\)/ && do {return "Mac System 8.5";};
|
2002-02-05 00:17:17 +03:00
|
|
|
# Bugzilla doesn't have an entry for 8.1
|
2001-11-09 08:32:43 +03:00
|
|
|
/\(.*Mac OS 8\.1.*\)/ && do {return "Mac System 8.0";};
|
|
|
|
/\(.*Mac OS 8\.0.*\)/ && do {return "Mac System 8.0";};
|
|
|
|
/\(.*Mac OS 8[^.].*\)/ && do {return "Mac System 8.0";};
|
|
|
|
/\(.*Mac OS 8.*\)/ && do {return "Mac System 8.6";};
|
2004-06-16 14:37:27 +04:00
|
|
|
/\(.*Mac OS X.*\)/ && do {return "Mac OS X 10.0";};
|
|
|
|
/\(.*Darwin.*\)/ && do {return "Mac OS X 10.0";};
|
2002-02-05 00:17:17 +03:00
|
|
|
# Silly
|
2001-11-09 08:32:43 +03:00
|
|
|
/\(.*Mac.*PowerPC.*\)/ && do {return "Mac System 9.x";};
|
|
|
|
/\(.*Mac.*PPC.*\)/ && do {return "Mac System 9.x";};
|
|
|
|
/\(.*Mac.*68k.*\)/ && do {return "Mac System 8.0";};
|
2002-02-05 00:17:17 +03:00
|
|
|
# Evil
|
2001-11-05 07:44:34 +03:00
|
|
|
/Amiga/i && do {return "other";};
|
2004-03-22 04:48:50 +03:00
|
|
|
/WinMosaic/ && do {return "Windows 95";};
|
2001-11-09 08:32:43 +03:00
|
|
|
/\(.*PowerPC.*\)/ && do {return "Mac System 9.x";};
|
|
|
|
/\(.*PPC.*\)/ && do {return "Mac System 9.x";};
|
|
|
|
/\(.*68K.*\)/ && do {return "Mac System 8.0";};
|
1999-05-06 02:05:19 +04:00
|
|
|
}
|
2004-08-28 12:58:14 +04:00
|
|
|
return "other";
|
1998-08-26 10:14:20 +04:00
|
|
|
}
|
|
|
|
}
|
2002-02-05 00:17:17 +03:00
|
|
|
##############################################################################
|
|
|
|
# End of subroutines
|
|
|
|
##############################################################################
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2004-03-27 06:51:44 +03:00
|
|
|
Bugzilla->login(LOGIN_REQUIRED) if (!(AnyEntryGroups()));
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
# 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) {
|
|
|
|
ValidateBugID($cloned_bug_id);
|
|
|
|
$cloned_bug = new Bugzilla::Bug($cloned_bug_id, $userid);
|
|
|
|
}
|
|
|
|
|
2002-11-24 22:56:34 +03:00
|
|
|
# We need to check and make sure
|
2002-02-05 00:17:17 +03:00
|
|
|
# that the user has permission to enter a bug against this product.
|
2002-11-24 22:56:34 +03:00
|
|
|
if(!CanEnterProduct($product))
|
2002-02-05 00:17:17 +03:00
|
|
|
{
|
2002-10-02 02:41:09 +04:00
|
|
|
ThrowUserError("entry_access_denied", { product => $product});
|
2002-02-05 00:17:17 +03:00
|
|
|
}
|
1999-03-09 05:33:58 +03:00
|
|
|
|
2002-02-05 00:17:17 +03:00
|
|
|
GetVersionTable();
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2002-08-12 09:43:05 +04:00
|
|
|
my $product_id = get_product_id($product);
|
|
|
|
|
2002-10-02 02:41:09 +04:00
|
|
|
if (0 == @{$::components{$product}}) {
|
2004-02-04 18:23:39 +03:00
|
|
|
ThrowUserError("no_components", {product => $product});
|
2002-02-05 00:17:17 +03:00
|
|
|
}
|
|
|
|
elsif (1 == @{$::components{$product}}) {
|
2000-01-15 20:25:51 +03:00
|
|
|
# Only one component; just pick it.
|
2004-04-07 07:38:26 +04:00
|
|
|
$cgi->param('component', $::components{$product}->[0]);
|
2000-01-15 20:25:51 +03:00
|
|
|
}
|
|
|
|
|
2002-04-27 10:57:16 +04:00
|
|
|
my @components;
|
2004-08-21 01:49:20 +04:00
|
|
|
|
2005-02-25 20:10:33 +03:00
|
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
my $sth = $dbh->prepare(
|
|
|
|
q{SELECT name, description, p1.login_name, p2.login_name
|
|
|
|
FROM components
|
|
|
|
LEFT JOIN profiles p1 ON components.initialowner = p1.userid
|
|
|
|
LEFT JOIN profiles p2 ON components.initialqacontact = p2.userid
|
|
|
|
WHERE product_id = ?
|
|
|
|
ORDER BY name});
|
|
|
|
|
|
|
|
$sth->execute($product_id);
|
|
|
|
while (my ($name, $description, $owner, $qacontact)
|
|
|
|
= $sth->fetchrow_array()) {
|
2003-04-27 11:12:53 +04:00
|
|
|
push @components, {
|
|
|
|
name => $name,
|
|
|
|
description => $description,
|
2005-02-25 20:10:33 +03:00
|
|
|
initialowner => $owner,
|
|
|
|
initialqacontact => $qacontact || '',
|
2003-04-27 11:12:53 +04:00
|
|
|
};
|
2002-04-27 10:57:16 +04:00
|
|
|
}
|
|
|
|
|
2002-02-05 00:17:17 +03:00
|
|
|
my %default;
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
$vars->{'product'} = $product;
|
|
|
|
$vars->{'component_'} = \@components;
|
|
|
|
|
|
|
|
$vars->{'priority'} = \@legal_priority;
|
|
|
|
$vars->{'bug_severity'} = \@legal_severity;
|
|
|
|
$vars->{'rep_platform'} = \@legal_platform;
|
|
|
|
$vars->{'op_sys'} = \@legal_opsys;
|
|
|
|
|
|
|
|
$vars->{'use_keywords'} = 1 if (@::legal_keywords);
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
$vars->{'assigned_to'} = formvalue('assigned_to');
|
|
|
|
$vars->{'assigned_to_disabled'} = !UserInGroup('editbugs');
|
|
|
|
$vars->{'cc_disabled'} = 0;
|
2005-01-21 02:22:10 +03:00
|
|
|
|
2005-02-25 20:10:33 +03:00
|
|
|
$vars->{'qa_contact'} = formvalue('qa_contact');
|
|
|
|
$vars->{'qa_contact_disabled'} = !UserInGroup('editbugs');
|
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
$vars->{'cloned_bug_id'} = $cloned_bug_id;
|
2005-01-21 02:22:10 +03:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
if ($cloned_bug_id) {
|
2000-03-10 19:25:03 +03:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
$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'};
|
2000-03-10 19:25:03 +03:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
$vars->{'short_desc'} = $cloned_bug->{'short_desc'};
|
|
|
|
$vars->{'bug_file_loc'} = $cloned_bug->{'bug_file_loc'};
|
2005-03-09 02:57:32 +03:00
|
|
|
$vars->{'keywords'} = $cloned_bug->keywords;
|
2005-01-31 22:15:55 +03:00
|
|
|
$vars->{'dependson'} = $cloned_bug_id;
|
|
|
|
$vars->{'blocked'} = "";
|
2005-02-25 19:58:40 +03:00
|
|
|
$vars->{'deadline'} = $cloned_bug->{'deadline'};
|
1999-06-29 04:24:41 +04:00
|
|
|
|
2005-03-09 02:57:32 +03:00
|
|
|
if (defined $cloned_bug->cc) {
|
|
|
|
$vars->{'cc'} = join (" ", @{$cloned_bug->cc});
|
2005-01-31 22:15:55 +03:00
|
|
|
} else {
|
|
|
|
$vars->{'cc'} = formvalue('cc');
|
|
|
|
}
|
|
|
|
|
|
|
|
# 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.
|
|
|
|
|
|
|
|
$cloned_bug->longdescs();
|
|
|
|
my $isprivate = $cloned_bug->{'longdescs'}->[0]->{'isprivate'};
|
|
|
|
|
|
|
|
$vars->{'comment'} = "";
|
|
|
|
$vars->{'commentprivacy'} = 0;
|
|
|
|
|
|
|
|
if ( !($isprivate) ||
|
|
|
|
( ( Param("insidergroup") ) &&
|
|
|
|
( UserInGroup(Param("insidergroup")) ) )
|
|
|
|
) {
|
|
|
|
$vars->{'comment'} = $cloned_bug->{'longdescs'}->[0]->{'body'};
|
|
|
|
$vars->{'commentprivacy'} = $isprivate;
|
|
|
|
}
|
2002-02-05 00:17:17 +03:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
# Ensure that the groupset information is set up for later use.
|
|
|
|
$cloned_bug->groups();
|
2002-02-05 00:17:17 +03:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
} # end of cloned bug entry form
|
2004-02-03 23:05:07 +03:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
else {
|
2005-01-07 23:25:20 +03:00
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
$default{'component_'} = formvalue('component');
|
|
|
|
$default{'priority'} = formvalue('priority', Param('defaultpriority'));
|
|
|
|
$default{'bug_severity'} = formvalue('bug_severity', Param('defaultseverity'));
|
|
|
|
$default{'rep_platform'} = pickplatform();
|
|
|
|
$default{'op_sys'} = pickos();
|
|
|
|
|
|
|
|
$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');
|
2005-02-25 19:58:40 +03:00
|
|
|
$vars->{'deadline'} = formvalue('deadline');
|
2005-01-31 22:15:55 +03:00
|
|
|
|
2005-03-17 18:50:45 +03:00
|
|
|
$vars->{'cc'} = join(', ', $cgi->param('cc'));
|
2005-01-31 22:15:55 +03:00
|
|
|
|
|
|
|
$vars->{'comment'} = formvalue('comment');
|
|
|
|
$vars->{'commentprivacy'} = formvalue('commentprivacy');
|
|
|
|
|
|
|
|
} # 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).
|
|
|
|
#
|
2002-11-19 02:49:18 +03:00
|
|
|
# Eventually maybe each product should have a "current version"
|
|
|
|
# parameter.
|
2002-02-05 00:17:17 +03:00
|
|
|
$vars->{'version'} = $::versions{$product} || [];
|
2005-01-31 22:15:55 +03:00
|
|
|
|
|
|
|
if ( ($cloned_bug_id) &&
|
|
|
|
("$product" eq "$cloned_bug->{'product'}" ) ) {
|
|
|
|
$default{'version'} = $cloned_bug->{'version'};
|
|
|
|
} elsif (formvalue('version')) {
|
2002-11-19 02:49:18 +03:00
|
|
|
$default{'version'} = formvalue('version');
|
2004-04-07 07:38:26 +04:00
|
|
|
} elsif (defined $cgi->cookie("VERSION-$product") &&
|
|
|
|
lsearch($vars->{'version'}, $cgi->cookie("VERSION-$product")) != -1) {
|
|
|
|
$default{'version'} = $cgi->cookie("VERSION-$product");
|
2002-06-11 17:32:01 +04:00
|
|
|
} else {
|
|
|
|
$default{'version'} = $vars->{'version'}->[$#{$vars->{'version'}}];
|
|
|
|
}
|
2002-02-05 00:17:17 +03:00
|
|
|
|
2005-02-16 00:51:12 +03:00
|
|
|
# Get list of milestones.
|
|
|
|
if ( Param('usetargetmilestone') ) {
|
|
|
|
$vars->{'target_milestone'} = $::target_milestone{$product};
|
|
|
|
if (formvalue('target_milestone')) {
|
|
|
|
$default{'target_milestone'} = formvalue('target_milestone');
|
|
|
|
} else {
|
|
|
|
SendSQL("SELECT defaultmilestone FROM products WHERE " .
|
|
|
|
"name = " . SqlQuote($product));
|
|
|
|
$default{'target_milestone'} = FetchOneColumn();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-12-12 04:40:31 +03:00
|
|
|
# List of status values for drop-down.
|
|
|
|
my @status;
|
2000-02-17 08:15:23 +03:00
|
|
|
|
2004-12-12 04:40:31 +03:00
|
|
|
# Construct the list of allowable values. There are three cases:
|
|
|
|
#
|
|
|
|
# case values
|
|
|
|
# product does not have confirmation NEW
|
|
|
|
# confirmation, user cannot confirm UNCONFIRMED
|
|
|
|
# confirmation, user can confirm NEW, UNCONFIRMED.
|
|
|
|
|
|
|
|
SendSQL("SELECT votestoconfirm FROM products WHERE name = " .
|
|
|
|
SqlQuote($product));
|
|
|
|
if (FetchOneColumn()) {
|
|
|
|
if (UserInGroup("editbugs") || UserInGroup("canconfirm")) {
|
|
|
|
push(@status, "NEW");
|
|
|
|
}
|
2005-02-08 19:22:26 +03:00
|
|
|
push(@status, 'UNCONFIRMED');
|
2004-12-12 04:40:31 +03:00
|
|
|
} else {
|
|
|
|
push(@status, "NEW");
|
2000-02-17 08:15:23 +03:00
|
|
|
}
|
|
|
|
|
2002-02-05 00:17:17 +03:00
|
|
|
$vars->{'bug_status'} = \@status;
|
2000-02-17 08:15:23 +03:00
|
|
|
|
2004-12-12 04:40:31 +03:00
|
|
|
# Get the default from a template value if it is legitimate.
|
|
|
|
# Otherwise, set the default to the first item on the list.
|
|
|
|
|
|
|
|
if (formvalue('bug_status') && (lsearch(\@status, formvalue('bug_status')) >= 0)) {
|
|
|
|
$default{'bug_status'} = formvalue('bug_status');
|
|
|
|
} else {
|
|
|
|
$default{'bug_status'} = $status[0];
|
|
|
|
}
|
|
|
|
|
2002-11-24 22:56:34 +03:00
|
|
|
SendSQL("SELECT DISTINCT groups.id, groups.name, groups.description, " .
|
|
|
|
"membercontrol, othercontrol " .
|
|
|
|
"FROM groups LEFT JOIN group_control_map " .
|
|
|
|
"ON group_id = id AND product_id = $product_id " .
|
|
|
|
"WHERE isbuggroup != 0 AND isactive != 0 ORDER BY description");
|
2002-02-05 00:17:17 +03:00
|
|
|
|
2002-09-22 21:15:13 +04:00
|
|
|
my @groups;
|
2002-02-05 00:17:17 +03:00
|
|
|
|
2002-09-22 21:15:13 +04:00
|
|
|
while (MoreSQLData()) {
|
2002-11-24 22:56:34 +03:00
|
|
|
my ($id, $groupname, $description, $membercontrol, $othercontrol)
|
|
|
|
= FetchSQLData();
|
|
|
|
# Only include groups if the entering user will have an option.
|
|
|
|
next if ((!$membercontrol)
|
|
|
|
|| ($membercontrol == CONTROLMAPNA)
|
|
|
|
|| ($membercontrol == CONTROLMAPMANDATORY)
|
|
|
|
|| (($othercontrol != CONTROLMAPSHOWN)
|
|
|
|
&& ($othercontrol != CONTROLMAPDEFAULT)
|
|
|
|
&& (!UserInGroup($groupname)))
|
|
|
|
);
|
2002-09-22 21:15:13 +04:00
|
|
|
my $check;
|
|
|
|
|
2005-01-31 22:15:55 +03:00
|
|
|
# If this is a cloned bug,
|
|
|
|
# AND the product for this bug is the same as for the original
|
|
|
|
# THEN set a group's checkbox if the original also had it on
|
|
|
|
# ELSE IF this is a bookmarked template
|
|
|
|
# THEN set a group's checkbox if was set in the bookmark
|
|
|
|
# ELSE
|
|
|
|
# set a groups's checkbox based on the group control map
|
|
|
|
#
|
|
|
|
if ( ($cloned_bug_id) &&
|
|
|
|
("$product" eq "$cloned_bug->{'product'}" ) ) {
|
|
|
|
foreach my $i (0..(@{$cloned_bug->{'groups'}}-1) ) {
|
|
|
|
if ($cloned_bug->{'groups'}->[$i]->{'bit'} == $id) {
|
|
|
|
$check = $cloned_bug->{'groups'}->[$i]->{'ison'};
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
elsif(formvalue("maketemplate") ne "") {
|
2002-09-22 21:15:13 +04:00
|
|
|
$check = formvalue("bit-$id", 0);
|
|
|
|
}
|
|
|
|
else {
|
2002-11-24 22:56:34 +03:00
|
|
|
# Checkbox is checked by default if $control is a default state.
|
|
|
|
$check = (($membercontrol == CONTROLMAPDEFAULT)
|
|
|
|
|| (($othercontrol == CONTROLMAPDEFAULT)
|
|
|
|
&& (!UserInGroup($groupname))));
|
2000-03-08 01:22:55 +03:00
|
|
|
}
|
|
|
|
|
2002-09-22 21:15:13 +04:00
|
|
|
my $group =
|
|
|
|
{
|
|
|
|
'bit' => $id ,
|
|
|
|
'checked' => $check ,
|
|
|
|
'description' => $description
|
|
|
|
};
|
|
|
|
|
|
|
|
push @groups, $group;
|
1999-06-29 04:24:41 +04:00
|
|
|
}
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2002-09-22 21:15:13 +04:00
|
|
|
$vars->{'group'} = \@groups;
|
|
|
|
|
2002-02-05 00:17:17 +03:00
|
|
|
$vars->{'default'} = \%default;
|
1998-08-26 10:14:20 +04:00
|
|
|
|
2002-09-18 03:28:24 +04:00
|
|
|
my $format =
|
2004-04-07 07:38:26 +04:00
|
|
|
GetFormat("bug/create/create", scalar $cgi->param('format'),
|
|
|
|
scalar $cgi->param('ctype'));
|
2002-04-27 10:57:16 +04:00
|
|
|
|
2003-05-05 05:15:38 +04:00
|
|
|
print $cgi->header($format->{'ctype'});
|
2002-09-18 03:28:24 +04:00
|
|
|
$template->process($format->{'template'}, $vars)
|
2002-04-24 11:24:50 +04:00
|
|
|
|| ThrowTemplateError($template->error());
|
2002-09-22 21:15:13 +04:00
|
|
|
|