1#!/usr/local/bin/perl -wT
2# This Source Code Form is subject to the terms of the Mozilla Public
3# License, v. 2.0. If a copy of the MPL was not distributed with this
4# file, You can obtain one at http://mozilla.org/MPL/2.0/.
5#
6# This Source Code Form is "Incompatible With Secondary Licenses", as
7# defined by the Mozilla Public License, v. 2.0.
8
9##############################################################################
10#
11# enter_bug.cgi
12# -------------
13# Displays bug entry form. Bug fields are specified through popup menus,
14# drop-down lists, or text fields. Default for these values can be
15# passed in as parameters to the cgi.
16#
17##############################################################################
18
19use strict;
20
21use lib qw(. lib);
22
23use Bugzilla;
24use Bugzilla::Constants;
25use Bugzilla::Util;
26use Bugzilla::Error;
27use Bugzilla::Bug;
28use Bugzilla::Hook;
29use Bugzilla::Classification;
30use Bugzilla::Token;
31use Bugzilla::Field;
32use Bugzilla::Status;
33use Bugzilla::UserAgent;
34
35use List::MoreUtils qw(none);
36
37my $user = Bugzilla->login(LOGIN_REQUIRED);
38
39my $cloned_bug;
40my $cloned_bug_id;
41
42my $cgi = Bugzilla->cgi;
43my $dbh = Bugzilla->dbh;
44my $template = Bugzilla->template;
45my $vars = {};
46
47# All pages point to the same part of the documentation.
48$vars->{'doc_section'} = 'bugreports.html';
49
50my $product_name = trim($cgi->param('product') || '');
51# Will contain the product object the bug is created in.
52my $product;
53
54if ($product_name eq '') {
55    # If the user cannot enter bugs in any product, stop here.
56    my @enterable_products = @{$user->get_enterable_products};
57    ThrowUserError('no_products') unless scalar(@enterable_products);
58
59    my $classification = Bugzilla->params->{'useclassification'} ?
60        scalar($cgi->param('classification')) : '__all';
61
62    # Unless a real classification name is given, we sort products
63    # by classification.
64    my @classifications;
65
66    unless ($classification && $classification ne '__all') {
67        @classifications = @{sort_products_by_classification(\@enterable_products)};
68    }
69
70    unless ($classification) {
71        # We know there is at least one classification available,
72        # else we would have stopped earlier.
73        if (scalar(@classifications) > 1) {
74            # We only need classification objects.
75            $vars->{'classifications'} = [map {$_->{'object'}} @classifications];
76
77            $vars->{'target'} = "enter_bug.cgi";
78            $vars->{'format'} = $cgi->param('format');
79            $vars->{'cloned_bug_id'} = $cgi->param('cloned_bug_id');
80
81            print $cgi->header();
82            $template->process("global/choose-classification.html.tmpl", $vars)
83               || ThrowTemplateError($template->error());
84            exit;
85        }
86        # If we come here, then there is only one classification available.
87        $classification = $classifications[0]->{'object'}->name;
88    }
89
90    # Keep only enterable products which are in the specified classification.
91    if ($classification ne "__all") {
92        my $class = new Bugzilla::Classification({'name' => $classification});
93        # If the classification doesn't exist, then there is no product in it.
94        if ($class) {
95            @enterable_products
96              = grep {$_->classification_id == $class->id} @enterable_products;
97            @classifications = ({object => $class, products => \@enterable_products});
98        }
99        else {
100            @enterable_products = ();
101        }
102    }
103
104    if (scalar(@enterable_products) == 0) {
105        ThrowUserError('no_products');
106    }
107    elsif (scalar(@enterable_products) > 1) {
108        $vars->{'classifications'} = \@classifications;
109        $vars->{'target'} = "enter_bug.cgi";
110        $vars->{'format'} = $cgi->param('format');
111        $vars->{'cloned_bug_id'} = $cgi->param('cloned_bug_id');
112
113        print $cgi->header();
114        $template->process("global/choose-product.html.tmpl", $vars)
115          || ThrowTemplateError($template->error());
116        exit;
117    } else {
118        # Only one product exists.
119        $product = $enterable_products[0];
120    }
121}
122
123# We need to check and make sure that the user has permission
124# to enter a bug against this product.
125$product = $user->can_enter_product($product || $product_name, THROW_ERROR);
126
127##############################################################################
128# Useful Subroutines
129##############################################################################
130sub formvalue {
131    my ($name, $default) = (@_);
132    return Bugzilla->cgi->param($name) || $default || "";
133}
134
135##############################################################################
136# End of subroutines
137##############################################################################
138
139my $has_editbugs = $user->in_group('editbugs', $product->id);
140my $has_canconfirm = $user->in_group('canconfirm', $product->id);
141
142# If a user is trying to clone a bug
143#   Check that the user has authorization to view the parent bug
144#   Create an instance of Bug that holds the info from the parent
145$cloned_bug_id = $cgi->param('cloned_bug_id');
146
147if ($cloned_bug_id) {
148    $cloned_bug = Bugzilla::Bug->check($cloned_bug_id);
149    $cloned_bug_id = $cloned_bug->id;
150}
151
152if (scalar(@{$product->components}) == 1) {
153    # Only one component; just pick it.
154    $cgi->param('component', $product->components->[0]->name);
155}
156
157my %default;
158
159$vars->{'product'}               = $product;
160
161$vars->{'priority'}              = get_legal_field_values('priority');
162$vars->{'bug_severity'}          = get_legal_field_values('bug_severity');
163$vars->{'rep_platform'}          = get_legal_field_values('rep_platform');
164$vars->{'op_sys'}                = get_legal_field_values('op_sys');
165
166$vars->{'assigned_to'}           = formvalue('assigned_to');
167$vars->{'assigned_to_disabled'}  = !$has_editbugs;
168$vars->{'cc_disabled'}           = 0;
169
170$vars->{'qa_contact'}           = formvalue('qa_contact');
171$vars->{'qa_contact_disabled'}  = !$has_editbugs;
172
173$vars->{'cloned_bug_id'}         = $cloned_bug_id;
174
175$vars->{'token'} = issue_session_token('create_bug');
176
177
178my @enter_bug_fields = grep { $_->enter_bug } Bugzilla->active_custom_fields;
179foreach my $field (@enter_bug_fields) {
180    my $cf_name = $field->name;
181    my $cf_value = $cgi->param($cf_name);
182    if (defined $cf_value) {
183        if ($field->type == FIELD_TYPE_MULTI_SELECT) {
184            $cf_value = [$cgi->param($cf_name)];
185        }
186        $default{$cf_name} = $vars->{$cf_name} = $cf_value;
187    }
188}
189
190# This allows the Field visibility and value controls to work with the
191# Classification and Product fields as a parent.
192$default{'classification'} = $product->classification->name;
193$default{'product'} = $product->name;
194
195if ($cloned_bug_id) {
196
197    $default{'component_'}    = $cloned_bug->component;
198    $default{'priority'}      = $cloned_bug->priority;
199    $default{'bug_severity'}  = $cloned_bug->bug_severity;
200    $default{'rep_platform'}  = $cloned_bug->rep_platform;
201    $default{'op_sys'}        = $cloned_bug->op_sys;
202
203    $vars->{'short_desc'}     = $cloned_bug->short_desc;
204    $vars->{'bug_file_loc'}   = $cloned_bug->bug_file_loc;
205    $vars->{'keywords'}       = $cloned_bug->keywords;
206    $vars->{'dependson'}      = join (", ", $cloned_bug_id, @{$cloned_bug->dependson});
207    $vars->{'blocked'}        = join (", ", @{$cloned_bug->blocked});
208    $vars->{'deadline'}       = $cloned_bug->deadline;
209    $vars->{'estimated_time'} = $cloned_bug->estimated_time;
210
211    if (scalar @{$cloned_bug->cc}) {
212        $vars->{'cc'}         = join (", ", @{$cloned_bug->cc});
213    } else {
214        $vars->{'cc'}         = formvalue('cc');
215    }
216
217    if ($cloned_bug->reporter->id != $user->id
218        && none { $_ eq $cloned_bug->reporter->login } @{$cloned_bug->cc}) {
219        $vars->{'cc'} = join (", ", $cloned_bug->reporter->login, $vars->{'cc'});
220    }
221
222    foreach my $field (@enter_bug_fields) {
223        my $field_name = $field->name;
224        $vars->{$field_name} = $cloned_bug->$field_name;
225    }
226
227    # We need to ensure that we respect the 'insider' status of
228    # the first comment, if it has one. Either way, make a note
229    # that this bug was cloned from another bug.
230    my $bug_desc = $cloned_bug->comments({ order => 'oldest_to_newest' })->[0];
231    my $isprivate = $bug_desc->is_private;
232
233    $vars->{'comment'} = "";
234    $vars->{'comment_is_private'} = 0;
235
236    if (!$isprivate || $user->is_insider) {
237        # We use "body" to avoid any format_comment text, which would be
238        # pointless to clone.
239        $vars->{'comment'} = $bug_desc->body;
240        $vars->{'comment_is_private'} = $isprivate;
241    }
242
243} # end of cloned bug entry form
244
245else {
246    $default{'component_'}    = formvalue('component');
247    $default{'priority'}      = formvalue('priority', Bugzilla->params->{'defaultpriority'});
248    $default{'bug_severity'}  = formvalue('bug_severity', Bugzilla->params->{'defaultseverity'});
249    $default{'rep_platform'}  = formvalue('rep_platform',
250                                          Bugzilla->params->{'defaultplatform'} || detect_platform());
251    $default{'op_sys'}        = formvalue('op_sys',
252                                          Bugzilla->params->{'defaultopsys'} || detect_op_sys());
253
254    $vars->{'alias'}          = formvalue('alias');
255    $vars->{'short_desc'}     = formvalue('short_desc');
256    $vars->{'bug_file_loc'}   = formvalue('bug_file_loc', "http://");
257    $vars->{'keywords'}       = formvalue('keywords');
258    $vars->{'dependson'}      = formvalue('dependson');
259    $vars->{'blocked'}        = formvalue('blocked');
260    $vars->{'deadline'}       = formvalue('deadline');
261    $vars->{'estimated_time'} = formvalue('estimated_time');
262
263    $vars->{'cc'}             = join(', ', $cgi->param('cc'));
264
265    $vars->{'comment'}        = formvalue('comment');
266    $vars->{'comment_is_private'} = formvalue('comment_is_private');
267
268} # end of normal/bookmarked entry form
269
270
271# IF this is a cloned bug,
272# AND the clone's product is the same as the parent's
273#   THEN use the version from the parent bug
274# ELSE IF a version is supplied in the URL
275#   THEN use it
276# ELSE IF there is a version in the cookie
277#   THEN use it (Posting a bug sets a cookie for the current version.)
278# ELSE
279#   The default version is the last one in the list (which, it is
280#   hoped, will be the most recent one).
281#
282# Eventually maybe each product should have a "current version"
283# parameter.
284$vars->{'version'} = $product->versions;
285
286my $version_cookie = $cgi->cookie("VERSION-" . $product->name);
287
288if ( ($cloned_bug_id) &&
289     ($product->name eq $cloned_bug->product ) ) {
290    $default{'version'} = $cloned_bug->version;
291} elsif (formvalue('version')) {
292    $default{'version'} = formvalue('version');
293} elsif (defined $version_cookie
294         and grep { $_->name eq $version_cookie } @{ $vars->{'version'} })
295{
296    $default{'version'} = $version_cookie;
297} else {
298    $default{'version'} = $vars->{'version'}->[$#{$vars->{'version'}}]->name;
299}
300
301# Get list of milestones.
302if ( Bugzilla->params->{'usetargetmilestone'} ) {
303    $vars->{'target_milestone'} = $product->milestones;
304    if (formvalue('target_milestone')) {
305       $default{'target_milestone'} = formvalue('target_milestone');
306    } else {
307       $default{'target_milestone'} = $product->default_milestone;
308    }
309}
310
311# Construct the list of allowable statuses.
312my @statuses = @{ Bugzilla::Bug->new_bug_statuses($product) };
313# Exclude closed states from the UI, even if the workflow allows them.
314# The back-end code will still accept them, though.
315# XXX We should remove this when the UI accepts closed statuses and update
316# Bugzilla::Bug->default_bug_status.
317@statuses = grep { $_->is_open } @statuses;
318
319scalar(@statuses) || ThrowUserError('no_initial_bug_status');
320
321$vars->{'bug_status'} = \@statuses;
322
323# Get the default from a template value if it is legitimate.
324# Otherwise, and only if the user has privs, set the default
325# to the first confirmed bug status on the list, if available.
326
327my $picked_status = formvalue('bug_status');
328if ($picked_status and grep($_->name eq $picked_status, @statuses)) {
329    $default{'bug_status'} = formvalue('bug_status');
330} else {
331    $default{'bug_status'} = Bugzilla::Bug->default_bug_status(@statuses);
332}
333
334my @groups = $cgi->param('groups');
335if ($cloned_bug) {
336    my @clone_groups = map { $_->name } @{ $cloned_bug->groups_in };
337    # It doesn't matter if there are duplicate names, since all we check
338    # for in the template is whether or not the group is set.
339    push(@groups, @clone_groups);
340}
341$default{'groups'} = \@groups;
342
343Bugzilla::Hook::process('enter_bug_entrydefaultvars', { vars => $vars });
344
345$vars->{'default'} = \%default;
346
347my $format = $template->get_format("bug/create/create",
348                                   scalar $cgi->param('format'),
349                                   scalar $cgi->param('ctype'));
350
351print $cgi->header($format->{'ctype'});
352$template->process($format->{'template'}, $vars)
353  || ThrowTemplateError($template->error());
354