# -*- 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. # # The Initial Developer of the Original Code is Frédéric Buclin. # Portions created by Frédéric Buclin are Copyright (C) 2007 # Frédéric Buclin. All Rights Reserved. # # Contributor(s): Frédéric Buclin <LpSolit@gmail.com> use strict; package Bugzilla::Status; use Bugzilla::Error; # This subclasses Bugzilla::Field::Choice instead of implementing # ChoiceInterface, because a bug status literally is a special type # of Field::Choice, not just an object that happens to have the same # methods. use base qw(Bugzilla::Field::Choice Exporter); @Bugzilla::Status::EXPORT = qw( BUG_STATE_OPEN SPECIAL_STATUS_WORKFLOW_ACTIONS is_open_state closed_bug_statuses ); ################################ ##### Initialization ##### ################################ use constant SPECIAL_STATUS_WORKFLOW_ACTIONS => qw( none duplicate change_resolution clearresolution ); use constant DB_TABLE => 'bug_status'; # This has all the standard Bugzilla::Field::Choice columns plus "is_open" sub DB_COLUMNS { return ($_[0]->SUPER::DB_COLUMNS, 'is_open'); } sub VALIDATORS { my $invocant = shift; my $validators = $invocant->SUPER::VALIDATORS; $validators->{is_open} = \&Bugzilla::Object::check_boolean; $validators->{value} = \&_check_value; return $validators; } ######################### # Database Manipulation # ######################### sub create { my $class = shift; my $self = $class->SUPER::create(@_); delete Bugzilla->request_cache->{status_bug_state_open}; add_missing_bug_status_transitions(); return $self; } sub remove_from_db { my $self = shift; my $dbh = Bugzilla->dbh; my $id = $self->id; $dbh->bz_start_transaction(); $self->SUPER::remove_from_db(); $dbh->do('DELETE FROM status_workflow WHERE old_status = ? OR new_status = ?', undef, $id, $id); $dbh->bz_commit_transaction(); delete Bugzilla->request_cache->{status_bug_state_open}; } ############################### ##### Accessors #### ############################### sub is_active { return $_[0]->{'isactive'}; } sub is_open { return $_[0]->{'is_open'}; } sub is_static { my $self = shift; if ($self->name eq 'UNCONFIRMED' || $self->name eq Bugzilla->params->{'duplicate_or_move_bug_status'}) { return 1; } return 0; } ############## # Validators # ############## sub _check_value { my $invocant = shift; my $value = $invocant->SUPER::_check_value(@_); if (grep { lc($value) eq lc($_) } SPECIAL_STATUS_WORKFLOW_ACTIONS) { ThrowUserError('fieldvalue_reserved_word', { field => $invocant->field, value => $value }); } return $value; } ############################### ##### Methods #### ############################### sub BUG_STATE_OPEN { my $dbh = Bugzilla->dbh; my $cache = Bugzilla->request_cache; $cache->{status_bug_state_open} ||= $dbh->selectcol_arrayref('SELECT value FROM bug_status WHERE is_open = 1'); return @{ $cache->{status_bug_state_open} }; } # Tells you whether or not the argument is a valid "open" state. sub is_open_state { my ($state) = @_; return (grep($_ eq $state, BUG_STATE_OPEN) ? 1 : 0); } sub closed_bug_statuses { my @bug_statuses = Bugzilla::Status->get_all; @bug_statuses = grep { !$_->is_open } @bug_statuses; return @bug_statuses; } sub can_change_to { my $self = shift; my $dbh = Bugzilla->dbh; if (!ref($self) || !defined $self->{'can_change_to'}) { my ($cond, @args, $self_exists); if (ref($self)) { $cond = '= ?'; push(@args, $self->id); $self_exists = 1; } else { $cond = 'IS NULL'; # Let's do it so that the code below works in all cases. $self = {}; } my $new_status_ids = $dbh->selectcol_arrayref("SELECT new_status FROM status_workflow INNER JOIN bug_status ON id = new_status WHERE isactive = 1 AND old_status $cond ORDER BY sortkey", undef, @args); # Allow the bug status to remain unchanged. push(@$new_status_ids, $self->id) if $self_exists; $self->{'can_change_to'} = Bugzilla::Status->new_from_list($new_status_ids); } return $self->{'can_change_to'}; } sub comment_required_on_change_from { my ($self, $old_status) = @_; my ($cond, $values) = $self->_status_condition($old_status); my ($require_comment) = Bugzilla->dbh->selectrow_array( "SELECT require_comment FROM status_workflow WHERE $cond", undef, @$values); return $require_comment; } # Used as a helper for various functions that have to deal with old_status # sometimes being NULL and sometimes having a value. sub _status_condition { my ($self, $old_status) = @_; my @values; my $cond = 'old_status IS NULL'; # For newly-filed bugs if ($old_status) { $cond = 'old_status = ?'; push(@values, $old_status->id); } $cond .= " AND new_status = ?"; push(@values, $self->id); return ($cond, \@values); } sub add_missing_bug_status_transitions { my $bug_status = shift || Bugzilla->params->{'duplicate_or_move_bug_status'}; my $dbh = Bugzilla->dbh; my $new_status = new Bugzilla::Status({name => $bug_status}); # Silently discard invalid bug statuses. $new_status || return; my $missing_statuses = $dbh->selectcol_arrayref('SELECT id FROM bug_status LEFT JOIN status_workflow ON old_status = id AND new_status = ? WHERE old_status IS NULL', undef, $new_status->id); my $sth = $dbh->prepare('INSERT INTO status_workflow (old_status, new_status) VALUES (?, ?)'); foreach my $old_status_id (@$missing_statuses) { next if ($old_status_id == $new_status->id); $sth->execute($old_status_id, $new_status->id); } } 1; __END__ =head1 NAME Bugzilla::Status - Bug status class. =head1 SYNOPSIS use Bugzilla::Status; my $bug_status = new Bugzilla::Status({ name => 'IN_PROGRESS' }); my $bug_status = new Bugzilla::Status(4); my @closed_bug_statuses = closed_bug_statuses(); Bugzilla::Status::add_missing_bug_status_transitions($bug_status); =head1 DESCRIPTION Status.pm represents a bug status object. It is an implementation of L<Bugzilla::Object>, and thus provides all methods that L<Bugzilla::Object> provides. The methods that are specific to C<Bugzilla::Status> are listed below. =head1 METHODS =over =item C<closed_bug_statuses> Description: Returns a list of C<Bugzilla::Status> objects which can have a resolution associated with them ("closed" bug statuses). Params: none. Returns: A list of Bugzilla::Status objects. =item C<can_change_to> Description: Returns the list of active statuses a bug can be changed to given the current bug status. If this method is called as a class method, then it returns all bug statuses available on bug creation. Params: none. Returns: A list of Bugzilla::Status objects. =item C<comment_required_on_change_from> =over =item B<Description> Checks if a comment is required to change to this status from another status, according to the current settings in the workflow. Note that this doesn't implement the checks enforced by the various C<commenton> parameters--those are checked by internal checks in L<Bugzilla::Bug>. =item B<Params> C<$old_status> - The status you're changing from. =item B<Returns> C<1> if a comment is required on this change, C<0> if not. =back =item C<add_missing_bug_status_transitions> Description: Insert all missing transitions to a given bug status. Params: $bug_status - The value (name) of a bug status. Returns: nothing. =back =cut