| # 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. |
| |
| package Bugzilla::Product; |
| |
| use 5.10.1; |
| use strict; |
| use warnings; |
| |
| use parent qw(Bugzilla::Field::ChoiceInterface Bugzilla::Object); |
| |
| use Bugzilla::Constants; |
| use Bugzilla::Util; |
| use Bugzilla::Error; |
| use Bugzilla::Group; |
| use Bugzilla::Version; |
| use Bugzilla::Milestone; |
| use Bugzilla::Field; |
| use Bugzilla::Status; |
| use Bugzilla::Install::Requirements; |
| use Bugzilla::Series; |
| use Bugzilla::Hook; |
| use Bugzilla::FlagType; |
| |
| use Scalar::Util qw(blessed); |
| |
| use constant DEFAULT_CLASSIFICATION_ID => 1; |
| |
| ############################### |
| #### Initialization #### |
| ############################### |
| |
| use constant IS_CONFIG => 1; |
| |
| use constant DB_TABLE => 'products'; |
| |
| use constant DB_COLUMNS => qw( |
| id |
| name |
| classification_id |
| description |
| isactive |
| defaultmilestone |
| allows_unconfirmed |
| ); |
| |
| use constant UPDATE_COLUMNS => qw( |
| name |
| description |
| defaultmilestone |
| isactive |
| allows_unconfirmed |
| ); |
| |
| use constant VALIDATORS => { |
| allows_unconfirmed => \&Bugzilla::Object::check_boolean, |
| classification => \&_check_classification, |
| name => \&_check_name, |
| description => \&_check_description, |
| version => \&_check_version, |
| defaultmilestone => \&_check_default_milestone, |
| isactive => \&Bugzilla::Object::check_boolean, |
| create_series => \&Bugzilla::Object::check_boolean |
| }; |
| |
| ############################### |
| #### Constructors ##### |
| ############################### |
| |
| sub create { |
| my $class = shift; |
| my $dbh = Bugzilla->dbh; |
| |
| $dbh->bz_start_transaction(); |
| |
| $class->check_required_create_fields(@_); |
| |
| my $params = $class->run_create_validators(@_); |
| # Some fields do not exist in the DB as is. |
| if (defined $params->{classification}) { |
| $params->{classification_id} = delete $params->{classification}; |
| } |
| my $version = delete $params->{version}; |
| my $create_series = delete $params->{create_series}; |
| |
| my $product = $class->insert_create_data($params); |
| Bugzilla->user->clear_product_cache(); |
| |
| # Add the new version and milestone into the DB as valid values. |
| Bugzilla::Version->create({ value => $version, product => $product }); |
| Bugzilla::Milestone->create({ value => $product->default_milestone, |
| product => $product }); |
| |
| # Create groups and series for the new product, if requested. |
| $product->_create_bug_group() if Bugzilla->params->{'makeproductgroups'}; |
| $product->_create_series() if $create_series; |
| |
| Bugzilla::Hook::process('product_end_of_create', { product => $product }); |
| |
| $dbh->bz_commit_transaction(); |
| Bugzilla->memcached->clear_config(); |
| return $product; |
| } |
| |
| # This is considerably faster than calling new_from_list three times |
| # for each product in the list, particularly with hundreds or thousands |
| # of products. |
| sub preload { |
| my ($products, $preload_flagtypes) = @_; |
| my %prods = map { $_->id => $_ } @$products; |
| my @prod_ids = keys %prods; |
| return unless @prod_ids; |
| |
| # We cannot |use| it due to a dependency loop with Bugzilla::User. |
| require Bugzilla::Component; |
| foreach my $field (qw(component version milestone)) { |
| my $classname = "Bugzilla::" . ucfirst($field); |
| my $objects = $classname->match({ product_id => \@prod_ids }); |
| |
| # Now populate the products with this set of objects. |
| foreach my $obj (@$objects) { |
| my $product_id = $obj->product_id; |
| $prods{$product_id}->{"${field}s"} ||= []; |
| push(@{$prods{$product_id}->{"${field}s"}}, $obj); |
| } |
| } |
| if ($preload_flagtypes) { |
| $_->flag_types foreach @$products; |
| } |
| } |
| |
| sub update { |
| my $self = shift; |
| my $dbh = Bugzilla->dbh; |
| |
| # Don't update the DB if something goes wrong below -> transaction. |
| $dbh->bz_start_transaction(); |
| my ($changes, $old_self) = $self->SUPER::update(@_); |
| |
| # Also update group settings. |
| if ($self->{check_group_controls}) { |
| require Bugzilla::Bug; |
| import Bugzilla::Bug qw(LogActivityEntry); |
| |
| my $old_settings = $old_self->group_controls; |
| my $new_settings = $self->group_controls; |
| my $timestamp = $dbh->selectrow_array('SELECT NOW()'); |
| |
| foreach my $gid (keys %$new_settings) { |
| my $old_setting = $old_settings->{$gid} || {}; |
| my $new_setting = $new_settings->{$gid}; |
| # If all new settings are 0 for a given group, we delete the entry |
| # from group_control_map, so we have to track it here. |
| my $all_zero = 1; |
| my @fields; |
| my @values; |
| |
| foreach my $field ('entry', 'membercontrol', 'othercontrol', 'canedit', |
| 'editcomponents', 'editbugs', 'canconfirm') |
| { |
| my $old_value = $old_setting->{$field}; |
| my $new_value = $new_setting->{$field}; |
| $all_zero = 0 if $new_value; |
| next if (defined $old_value && $old_value == $new_value); |
| push(@fields, $field); |
| # The value has already been validated. |
| detaint_natural($new_value); |
| push(@values, $new_value); |
| } |
| # Is there anything to update? |
| next unless scalar @fields; |
| |
| if ($all_zero) { |
| $dbh->do('DELETE FROM group_control_map |
| WHERE product_id = ? AND group_id = ?', |
| undef, $self->id, $gid); |
| } |
| else { |
| if (exists $old_setting->{group}) { |
| # There is already an entry in the DB. |
| my $set_fields = join(', ', map {"$_ = ?"} @fields); |
| $dbh->do("UPDATE group_control_map SET $set_fields |
| WHERE product_id = ? AND group_id = ?", |
| undef, (@values, $self->id, $gid)); |
| } |
| else { |
| # No entry yet. |
| my $fields = join(', ', @fields); |
| # +2 because of the product and group IDs. |
| my $qmarks = join(',', ('?') x (scalar @fields + 2)); |
| $dbh->do("INSERT INTO group_control_map (product_id, group_id, $fields) |
| VALUES ($qmarks)", undef, ($self->id, $gid, @values)); |
| } |
| } |
| |
| # If the group is mandatory, restrict all bugs to it. |
| if ($new_setting->{membercontrol} == CONTROLMAPMANDATORY) { |
| my $bug_ids = |
| $dbh->selectcol_arrayref('SELECT bugs.bug_id |
| FROM bugs |
| LEFT JOIN bug_group_map |
| ON bug_group_map.bug_id = bugs.bug_id |
| AND group_id = ? |
| WHERE product_id = ? |
| AND bug_group_map.bug_id IS NULL', |
| undef, $gid, $self->id); |
| |
| if (scalar @$bug_ids) { |
| my $sth = $dbh->prepare('INSERT INTO bug_group_map (bug_id, group_id) |
| VALUES (?, ?)'); |
| |
| foreach my $bug_id (@$bug_ids) { |
| $sth->execute($bug_id, $gid); |
| # Add this change to the bug history. |
| LogActivityEntry($bug_id, 'bug_group', '', |
| $new_setting->{group}->name, |
| Bugzilla->user->id, $timestamp); |
| } |
| push(@{$changes->{'_group_controls'}->{'now_mandatory'}}, |
| {name => $new_setting->{group}->name, |
| bug_count => scalar @$bug_ids}); |
| } |
| } |
| # If the group can no longer be used to restrict bugs, remove them. |
| elsif ($new_setting->{membercontrol} == CONTROLMAPNA) { |
| my $bug_ids = |
| $dbh->selectcol_arrayref('SELECT bugs.bug_id |
| FROM bugs |
| INNER JOIN bug_group_map |
| ON bug_group_map.bug_id = bugs.bug_id |
| WHERE product_id = ? AND group_id = ?', |
| undef, $self->id, $gid); |
| |
| if (scalar @$bug_ids) { |
| $dbh->do('DELETE FROM bug_group_map WHERE group_id = ? AND ' . |
| $dbh->sql_in('bug_id', $bug_ids), undef, $gid); |
| |
| # Add this change to the bug history. |
| foreach my $bug_id (@$bug_ids) { |
| LogActivityEntry($bug_id, 'bug_group', |
| $old_setting->{group}->name, '', |
| Bugzilla->user->id, $timestamp); |
| } |
| push(@{$changes->{'_group_controls'}->{'now_na'}}, |
| {name => $old_setting->{group}->name, |
| bug_count => scalar @$bug_ids}); |
| } |
| } |
| } |
| |
| delete $self->{groups_available}; |
| delete $self->{groups_mandatory}; |
| } |
| $dbh->bz_commit_transaction(); |
| # Changes have been committed. |
| delete $self->{check_group_controls}; |
| Bugzilla->user->clear_product_cache(); |
| Bugzilla->memcached->clear_config(); |
| |
| return $changes; |
| } |
| |
| sub remove_from_db { |
| my ($self, $params) = @_; |
| my $user = Bugzilla->user; |
| my $dbh = Bugzilla->dbh; |
| |
| $dbh->bz_start_transaction(); |
| |
| $self->_check_if_controller(); |
| |
| if ($self->bug_count) { |
| if (Bugzilla->params->{'allowbugdeletion'}) { |
| require Bugzilla::Bug; |
| foreach my $bug_id (@{$self->bug_ids}) { |
| # Note that we allow the user to delete bugs they can't see, |
| # which is okay, because they're deleting the whole Product. |
| my $bug = new Bugzilla::Bug($bug_id); |
| $bug->remove_from_db(); |
| } |
| } |
| else { |
| ThrowUserError('product_has_bugs', { nb => $self->bug_count }); |
| } |
| } |
| |
| if ($params->{delete_series}) { |
| my $series_ids = |
| $dbh->selectcol_arrayref('SELECT series_id |
| FROM series |
| INNER JOIN series_categories |
| ON series_categories.id = series.category |
| WHERE series_categories.name = ?', |
| undef, $self->name); |
| |
| if (scalar @$series_ids) { |
| $dbh->do('DELETE FROM series WHERE ' . $dbh->sql_in('series_id', $series_ids)); |
| } |
| |
| # If no subcategory uses this product name, completely purge it. |
| my $in_use = |
| $dbh->selectrow_array('SELECT 1 |
| FROM series |
| INNER JOIN series_categories |
| ON series_categories.id = series.subcategory |
| WHERE series_categories.name = ? ' . |
| $dbh->sql_limit(1), |
| undef, $self->name); |
| if (!$in_use) { |
| $dbh->do('DELETE FROM series_categories WHERE name = ?', undef, $self->name); |
| } |
| } |
| |
| $self->SUPER::remove_from_db(); |
| |
| $dbh->bz_commit_transaction(); |
| Bugzilla->memcached->clear_config(); |
| |
| # We have to delete these internal variables, else we get |
| # the old lists of products and classifications again. |
| delete $user->{selectable_products}; |
| delete $user->{selectable_classifications}; |
| |
| } |
| |
| ############################### |
| #### Validators #### |
| ############################### |
| |
| sub _check_classification { |
| my ($invocant, $classification_name) = @_; |
| |
| my $classification_id = 1; |
| if (Bugzilla->params->{'useclassification'}) { |
| my $classification = Bugzilla::Classification->check($classification_name); |
| $classification_id = $classification->id; |
| } |
| return $classification_id; |
| } |
| |
| sub _check_name { |
| my ($invocant, $name) = @_; |
| |
| $name = trim($name); |
| $name || ThrowUserError('product_blank_name'); |
| |
| if (length($name) > MAX_PRODUCT_SIZE) { |
| ThrowUserError('product_name_too_long', {'name' => $name}); |
| } |
| |
| my $product = new Bugzilla::Product({name => $name}); |
| if ($product && (!ref $invocant || $product->id != $invocant->id)) { |
| # Check for exact case sensitive match: |
| if ($product->name eq $name) { |
| ThrowUserError('product_name_already_in_use', {'product' => $product->name}); |
| } |
| else { |
| ThrowUserError('product_name_diff_in_case', {'product' => $name, |
| 'existing_product' => $product->name}); |
| } |
| } |
| return $name; |
| } |
| |
| sub _check_description { |
| my ($invocant, $description) = @_; |
| |
| $description = trim($description); |
| $description || ThrowUserError('product_must_have_description'); |
| return $description; |
| } |
| |
| sub _check_version { |
| my ($invocant, $version) = @_; |
| |
| $version = trim($version); |
| $version || ThrowUserError('product_must_have_version'); |
| # We will check the version length when Bugzilla::Version->create will do it. |
| return $version; |
| } |
| |
| sub _check_default_milestone { |
| my ($invocant, $milestone) = @_; |
| |
| # Do nothing if target milestones are not in use. |
| unless (Bugzilla->params->{'usetargetmilestone'}) { |
| return (ref $invocant) ? $invocant->default_milestone : '---'; |
| } |
| |
| $milestone = trim($milestone); |
| |
| if (ref $invocant) { |
| # The default milestone must be one of the existing milestones. |
| my $mil_obj = new Bugzilla::Milestone({name => $milestone, product => $invocant}); |
| |
| $mil_obj || ThrowUserError('product_must_define_defaultmilestone', |
| {product => $invocant->name, |
| milestone => $milestone}); |
| } |
| else { |
| $milestone ||= '---'; |
| } |
| return $milestone; |
| } |
| |
| sub _check_milestone_url { |
| my ($invocant, $url) = @_; |
| |
| # Do nothing if target milestones are not in use. |
| unless (Bugzilla->params->{'usetargetmilestone'}) { |
| return (ref $invocant) ? $invocant->milestone_url : ''; |
| } |
| |
| $url = trim($url || ''); |
| return $url; |
| } |
| |
| ##################################### |
| # Implement Bugzilla::Field::Choice # |
| ##################################### |
| |
| use constant FIELD_NAME => 'product'; |
| use constant is_default => 0; |
| |
| ############################### |
| #### Methods #### |
| ############################### |
| |
| sub _create_bug_group { |
| my $self = shift; |
| my $dbh = Bugzilla->dbh; |
| |
| my $group_name = $self->name; |
| while (new Bugzilla::Group({name => $group_name})) { |
| $group_name .= '_'; |
| } |
| my $group_description = get_text('bug_group_description', {product => $self}); |
| |
| my $group = Bugzilla::Group->create({name => $group_name, |
| description => $group_description, |
| isbuggroup => 1}); |
| |
| # Associate the new group and new product. |
| $dbh->do('INSERT INTO group_control_map |
| (group_id, product_id, membercontrol, othercontrol) |
| VALUES (?, ?, ?, ?)', |
| undef, ($group->id, $self->id, CONTROLMAPDEFAULT, CONTROLMAPNA)); |
| } |
| |
| sub _create_series { |
| my $self = shift; |
| |
| my @series; |
| # We do every status, every resolution, and an "opened" one as well. |
| foreach my $bug_status (@{get_legal_field_values('bug_status')}) { |
| push(@series, [$bug_status, "bug_status=" . url_quote($bug_status)]); |
| } |
| |
| foreach my $resolution (@{get_legal_field_values('resolution')}) { |
| next if !$resolution; |
| push(@series, [$resolution, "resolution=" . url_quote($resolution)]); |
| } |
| |
| my @openedstatuses = BUG_STATE_OPEN; |
| my $query = join("&", map { "bug_status=" . url_quote($_) } @openedstatuses); |
| push(@series, [get_text('series_all_open'), $query]); |
| |
| foreach my $sdata (@series) { |
| my $series = new Bugzilla::Series(undef, $self->name, |
| get_text('series_subcategory'), |
| $sdata->[0], Bugzilla->user->id, 1, |
| $sdata->[1] . "&product=" . url_quote($self->name), 1); |
| $series->writeToDatabase(); |
| } |
| } |
| |
| sub set_name { $_[0]->set('name', $_[1]); } |
| sub set_description { $_[0]->set('description', $_[1]); } |
| sub set_default_milestone { $_[0]->set('defaultmilestone', $_[1]); } |
| sub set_is_active { $_[0]->set('isactive', $_[1]); } |
| sub set_allows_unconfirmed { $_[0]->set('allows_unconfirmed', $_[1]); } |
| |
| sub set_group_controls { |
| my ($self, $group, $settings) = @_; |
| |
| $group->is_active_bug_group |
| || ThrowUserError('product_illegal_group', {group => $group}); |
| |
| scalar(keys %$settings) |
| || ThrowCodeError('product_empty_group_controls', {group => $group}); |
| |
| # We store current settings for this group. |
| my $gs = $self->group_controls->{$group->id}; |
| # If there is no entry for this group yet, create a default hash. |
| unless (defined $gs) { |
| $gs = { entry => 0, |
| membercontrol => CONTROLMAPNA, |
| othercontrol => CONTROLMAPNA, |
| canedit => 0, |
| editcomponents => 0, |
| editbugs => 0, |
| canconfirm => 0, |
| group => $group }; |
| } |
| |
| # Both settings must be defined, or none of them can be updated. |
| if (defined $settings->{membercontrol} && defined $settings->{othercontrol}) { |
| # Legality of control combination is a function of |
| # membercontrol\othercontrol |
| # NA SH DE MA |
| # NA + - - - |
| # SH + + + + |
| # DE + - + + |
| # MA - - - + |
| foreach my $field ('membercontrol', 'othercontrol') { |
| my ($is_legal) = grep { $settings->{$field} == $_ } |
| (CONTROLMAPNA, CONTROLMAPSHOWN, CONTROLMAPDEFAULT, CONTROLMAPMANDATORY); |
| defined $is_legal || ThrowCodeError('product_illegal_group_control', |
| { field => $field, value => $settings->{$field} }); |
| } |
| unless ($settings->{membercontrol} == $settings->{othercontrol} |
| || $settings->{membercontrol} == CONTROLMAPSHOWN |
| || ($settings->{membercontrol} == CONTROLMAPDEFAULT |
| && $settings->{othercontrol} != CONTROLMAPSHOWN)) |
| { |
| ThrowUserError('illegal_group_control_combination', {groupname => $group->name}); |
| } |
| $gs->{membercontrol} = $settings->{membercontrol}; |
| $gs->{othercontrol} = $settings->{othercontrol}; |
| } |
| |
| foreach my $field ('entry', 'canedit', 'editcomponents', 'editbugs', 'canconfirm') { |
| next unless defined $settings->{$field}; |
| $gs->{$field} = $settings->{$field} ? 1 : 0; |
| } |
| $self->{group_controls}->{$group->id} = $gs; |
| $self->{check_group_controls} = 1; |
| } |
| |
| sub components { |
| my $self = shift; |
| my $dbh = Bugzilla->dbh; |
| |
| if (!defined $self->{components}) { |
| my $ids = $dbh->selectcol_arrayref(q{ |
| SELECT id FROM components |
| WHERE product_id = ? |
| ORDER BY name}, undef, $self->id); |
| |
| require Bugzilla::Component; |
| $self->{components} = Bugzilla::Component->new_from_list($ids); |
| } |
| return $self->{components}; |
| } |
| |
| sub group_controls { |
| my ($self, $full_data) = @_; |
| my $dbh = Bugzilla->dbh; |
| |
| # By default, we don't return groups which are not listed in |
| # group_control_map. If $full_data is true, then we also |
| # return groups whose settings could be set for the product. |
| my $where_or_and = 'WHERE'; |
| my $and_or_where = 'AND'; |
| if ($full_data) { |
| $where_or_and = 'AND'; |
| $and_or_where = 'WHERE'; |
| } |
| |
| # If $full_data is true, we collect all the data in all cases, |
| # even if the cache is already populated. |
| # $full_data is never used except in the very special case where |
| # all configurable bug groups are displayed to administrators, |
| # so we don't care about collecting all the data again in this case. |
| if (!defined $self->{group_controls} || $full_data) { |
| # Include name to the list, to allow us sorting data more easily. |
| my $query = qq{SELECT id, name, entry, membercontrol, othercontrol, |
| canedit, editcomponents, editbugs, canconfirm |
| FROM groups |
| LEFT JOIN group_control_map |
| ON id = group_id |
| $where_or_and product_id = ? |
| $and_or_where isbuggroup = 1}; |
| $self->{group_controls} = |
| $dbh->selectall_hashref($query, 'id', undef, $self->id); |
| |
| # For each group ID listed above, create and store its group object. |
| my @gids = keys %{$self->{group_controls}}; |
| my $groups = Bugzilla::Group->new_from_list(\@gids); |
| $self->{group_controls}->{$_->id}->{group} = $_ foreach @$groups; |
| } |
| |
| # We never cache bug counts, for the same reason as above. |
| if ($full_data) { |
| my $counts = |
| $dbh->selectall_arrayref('SELECT group_id, COUNT(bugs.bug_id) AS bug_count |
| FROM bug_group_map |
| INNER JOIN bugs |
| ON bugs.bug_id = bug_group_map.bug_id |
| WHERE bugs.product_id = ? ' . |
| $dbh->sql_group_by('group_id'), |
| {'Slice' => {}}, $self->id); |
| foreach my $data (@$counts) { |
| $self->{group_controls}->{$data->{group_id}}->{bug_count} = $data->{bug_count}; |
| } |
| } |
| return $self->{group_controls}; |
| } |
| |
| sub groups_available { |
| my ($self) = @_; |
| return $self->{groups_available} if defined $self->{groups_available}; |
| my $dbh = Bugzilla->dbh; |
| my $shown = CONTROLMAPSHOWN; |
| my $default = CONTROLMAPDEFAULT; |
| my %member_groups = @{ $dbh->selectcol_arrayref( |
| "SELECT group_id, membercontrol |
| FROM group_control_map |
| INNER JOIN groups ON group_control_map.group_id = groups.id |
| WHERE isbuggroup = 1 AND isactive = 1 AND product_id = ? |
| AND (membercontrol = $shown OR membercontrol = $default) |
| AND " . Bugzilla->user->groups_in_sql(), |
| {Columns=>[1,2]}, $self->id) }; |
| # We don't need to check the group membership here, because we only |
| # add these groups to the list below if the group isn't already listed |
| # for membercontrol. |
| my %other_groups = @{ $dbh->selectcol_arrayref( |
| "SELECT group_id, othercontrol |
| FROM group_control_map |
| INNER JOIN groups ON group_control_map.group_id = groups.id |
| WHERE isbuggroup = 1 AND isactive = 1 AND product_id = ? |
| AND (othercontrol = $shown OR othercontrol = $default)", |
| {Columns=>[1,2]}, $self->id) }; |
| |
| # If the user is a member, then we use the membercontrol value. |
| # Otherwise, we use the othercontrol value. |
| my %all_groups = %member_groups; |
| foreach my $id (keys %other_groups) { |
| if (!defined $all_groups{$id}) { |
| $all_groups{$id} = $other_groups{$id}; |
| } |
| } |
| |
| my $available = Bugzilla::Group->new_from_list([keys %all_groups]); |
| foreach my $group (@$available) { |
| $group->{is_default} = 1 if $all_groups{$group->id} == $default; |
| } |
| |
| $self->{groups_available} = $available; |
| return $self->{groups_available}; |
| } |
| |
| sub groups_mandatory { |
| my ($self) = @_; |
| return $self->{groups_mandatory} if $self->{groups_mandatory}; |
| my $groups = Bugzilla->user->groups_as_string; |
| my $mandatory = CONTROLMAPMANDATORY; |
| # For membercontrol we don't check group_id IN, because if membercontrol |
| # is Mandatory, the group is Mandatory for everybody, regardless of their |
| # group membership. |
| my $ids = Bugzilla->dbh->selectcol_arrayref( |
| "SELECT group_id |
| FROM group_control_map |
| INNER JOIN groups ON group_control_map.group_id = groups.id |
| WHERE product_id = ? AND isactive = 1 |
| AND (membercontrol = $mandatory |
| OR (othercontrol = $mandatory |
| AND group_id NOT IN ($groups)))", |
| undef, $self->id); |
| $self->{groups_mandatory} = Bugzilla::Group->new_from_list($ids); |
| return $self->{groups_mandatory}; |
| } |
| |
| # We don't just check groups_valid, because we want to know specifically |
| # if this group can be validly set by the currently-logged-in user. |
| sub group_is_settable { |
| my ($self, $group) = @_; |
| |
| return 0 unless ($group->is_active && $group->is_bug_group); |
| |
| my $is_mandatory = grep { $group->id == $_->id } |
| @{ $self->groups_mandatory }; |
| my $is_available = grep { $group->id == $_->id } |
| @{ $self->groups_available }; |
| return ($is_mandatory or $is_available) ? 1 : 0; |
| } |
| |
| sub group_is_valid { |
| my ($self, $group) = @_; |
| return grep($_->id == $group->id, @{ $self->groups_valid }) ? 1 : 0; |
| } |
| |
| sub groups_valid { |
| my ($self) = @_; |
| return $self->{groups_valid} if defined $self->{groups_valid}; |
| |
| # Note that we don't check OtherControl below, because there is no |
| # valid NA/* combination. |
| my $ids = Bugzilla->dbh->selectcol_arrayref( |
| "SELECT DISTINCT group_id |
| FROM group_control_map AS gcm |
| INNER JOIN groups ON gcm.group_id = groups.id |
| WHERE product_id = ? AND isbuggroup = 1 |
| AND membercontrol != " . CONTROLMAPNA, undef, $self->id); |
| $self->{groups_valid} = Bugzilla::Group->new_from_list($ids); |
| return $self->{groups_valid}; |
| } |
| |
| sub versions { |
| my $self = shift; |
| my $dbh = Bugzilla->dbh; |
| |
| if (!defined $self->{versions}) { |
| my $ids = $dbh->selectcol_arrayref(q{ |
| SELECT id FROM versions |
| WHERE product_id = ?}, undef, $self->id); |
| |
| $self->{versions} = Bugzilla::Version->new_from_list($ids); |
| } |
| return $self->{versions}; |
| } |
| |
| sub milestones { |
| my $self = shift; |
| my $dbh = Bugzilla->dbh; |
| |
| if (!defined $self->{milestones}) { |
| my $ids = $dbh->selectcol_arrayref(q{ |
| SELECT id FROM milestones |
| WHERE product_id = ?}, undef, $self->id); |
| |
| $self->{milestones} = Bugzilla::Milestone->new_from_list($ids); |
| } |
| return $self->{milestones}; |
| } |
| |
| sub bug_count { |
| my $self = shift; |
| my $dbh = Bugzilla->dbh; |
| |
| if (!defined $self->{'bug_count'}) { |
| $self->{'bug_count'} = $dbh->selectrow_array(qq{ |
| SELECT COUNT(bug_id) FROM bugs |
| WHERE product_id = ?}, undef, $self->id); |
| |
| } |
| return $self->{'bug_count'}; |
| } |
| |
| sub bug_ids { |
| my $self = shift; |
| my $dbh = Bugzilla->dbh; |
| |
| if (!defined $self->{'bug_ids'}) { |
| $self->{'bug_ids'} = |
| $dbh->selectcol_arrayref(q{SELECT bug_id FROM bugs |
| WHERE product_id = ?}, |
| undef, $self->id); |
| } |
| return $self->{'bug_ids'}; |
| } |
| |
| sub user_has_access { |
| my ($self, $user) = @_; |
| |
| return Bugzilla->dbh->selectrow_array( |
| 'SELECT CASE WHEN group_id IS NULL THEN 1 ELSE 0 END |
| FROM products LEFT JOIN group_control_map |
| ON group_control_map.product_id = products.id |
| AND group_control_map.entry != 0 |
| AND group_id NOT IN (' . $user->groups_as_string . ') |
| WHERE products.id = ? ' . Bugzilla->dbh->sql_limit(1), |
| undef, $self->id); |
| } |
| |
| sub flag_types { |
| my $self = shift; |
| |
| return $self->{'flag_types'} if defined $self->{'flag_types'}; |
| |
| # We cache flag types to avoid useless calls to get_clusions(). |
| my $cache = Bugzilla->request_cache->{flag_types_per_product} ||= {}; |
| $self->{flag_types} = {}; |
| my $prod_id = $self->id; |
| my $flagtypes = Bugzilla::FlagType::match({ product_id => $prod_id }); |
| |
| foreach my $type ('bug', 'attachment') { |
| my @flags = grep { $_->target_type eq $type } @$flagtypes; |
| $self->{flag_types}->{$type} = \@flags; |
| |
| # Also populate component flag types, while we are here. |
| foreach my $comp (@{$self->components}) { |
| $comp->{flag_types} ||= {}; |
| my $comp_id = $comp->id; |
| |
| foreach my $flag (@flags) { |
| my $flag_id = $flag->id; |
| $cache->{$flag_id} ||= $flag; |
| my $i = $cache->{$flag_id}->inclusions_as_hash; |
| my $e = $cache->{$flag_id}->exclusions_as_hash; |
| my $included = $i->{0}->{0} || $i->{0}->{$comp_id} |
| || $i->{$prod_id}->{0} || $i->{$prod_id}->{$comp_id}; |
| my $excluded = $e->{0}->{0} || $e->{0}->{$comp_id} |
| || $e->{$prod_id}->{0} || $e->{$prod_id}->{$comp_id}; |
| push(@{$comp->{flag_types}->{$type}}, $flag) if ($included && !$excluded); |
| } |
| } |
| } |
| return $self->{'flag_types'}; |
| } |
| |
| sub classification { |
| my $self = shift; |
| $self->{'classification'} ||= |
| new Bugzilla::Classification({ id => $self->classification_id, cache => 1 }); |
| return $self->{'classification'}; |
| } |
| |
| ############################### |
| #### Accessors ###### |
| ############################### |
| |
| sub allows_unconfirmed { return $_[0]->{'allows_unconfirmed'}; } |
| sub description { return $_[0]->{'description'}; } |
| sub is_active { return $_[0]->{'isactive'}; } |
| sub default_milestone { return $_[0]->{'defaultmilestone'}; } |
| sub classification_id { return $_[0]->{'classification_id'}; } |
| |
| ############################### |
| #### Subroutines ###### |
| ############################### |
| |
| sub check { |
| my ($class, $params) = @_; |
| $params = { name => $params } if !ref $params; |
| if (!$params->{allow_inaccessible}) { |
| $params->{_error} = 'product_access_denied'; |
| } |
| my $product = $class->SUPER::check($params); |
| |
| if (!$params->{allow_inaccessible} |
| && !Bugzilla->user->can_access_product($product)) |
| { |
| ThrowUserError('product_access_denied', $params); |
| } |
| return $product; |
| } |
| |
| 1; |
| |
| __END__ |
| |
| =head1 NAME |
| |
| Bugzilla::Product - Bugzilla product class. |
| |
| =head1 SYNOPSIS |
| |
| use Bugzilla::Product; |
| |
| my $product = new Bugzilla::Product(1); |
| my $product = new Bugzilla::Product({ name => 'AcmeProduct' }); |
| |
| my @components = $product->components(); |
| my $groups_controls = $product->group_controls(); |
| my @milestones = $product->milestones(); |
| my @versions = $product->versions(); |
| my $bugcount = $product->bug_count(); |
| my $bug_ids = $product->bug_ids(); |
| my $has_access = $product->user_has_access($user); |
| my $flag_types = $product->flag_types(); |
| my $classification = $product->classification(); |
| |
| my $id = $product->id; |
| my $name = $product->name; |
| my $description = $product->description; |
| my isactive = $product->is_active; |
| my $defaultmilestone = $product->default_milestone; |
| my $classificationid = $product->classification_id; |
| my $allows_unconfirmed = $product->allows_unconfirmed; |
| |
| =head1 DESCRIPTION |
| |
| Product.pm represents a product 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::Product> are listed |
| below. |
| |
| =head1 METHODS |
| |
| =over |
| |
| =item C<components> |
| |
| Description: Returns an array of component objects belonging to |
| the product. |
| |
| Params: none. |
| |
| Returns: An array of Bugzilla::Component object. |
| |
| =item C<group_controls()> |
| |
| Description: Returns a hash (group id as key) with all product |
| group controls. |
| |
| Params: $full_data (optional, false by default) - when true, |
| the number of bugs per group applicable to the product |
| is also returned. Moreover, bug groups which have no |
| special settings for the product are also returned. |
| |
| Returns: A hash with group id as key and hash containing |
| a Bugzilla::Group object and the properties of group |
| relative to the product. |
| |
| =item C<groups_available> |
| |
| Tells you what groups are set to Default or Shown for the |
| currently-logged-in user (taking into account both OtherControl and |
| MemberControl). Returns an arrayref of L<Bugzilla::Group> objects with |
| an extra hash keys set, C<is_default>, which is true if the group |
| is set to Default for the currently-logged-in user. |
| |
| =item C<groups_mandatory> |
| |
| Tells you what groups are mandatory for bugs in this product, for the |
| currently-logged-in user. Returns an arrayref of C<Bugzilla::Group> objects. |
| |
| =item C<group_is_settable> |
| |
| =over |
| |
| =item B<Description> |
| |
| Tells you whether or not the currently-logged-in user can set a group |
| on a bug (whether or not they match the MemberControl/OtherControl |
| settings for a group in this product). Groups that are C<Mandatory> for |
| the currently-loggeed-in user are also acceptable since from Bugzilla's |
| perspective, there's no problem with "setting" a Mandatory group on |
| a bug. (In fact, the user I<must> set the Mandatory group on the bug.) |
| |
| =item B<Params> |
| |
| =over |
| |
| =item C<$group> - A L<Bugzilla::Group> object. |
| |
| =back |
| |
| =item B<Returns> |
| |
| C<1> if the group is valid in this product, C<0> otherwise. |
| |
| =back |
| |
| |
| =item C<groups_valid> |
| |
| =over |
| |
| =item B<Description> |
| |
| Returns an arrayref of L<Bugzilla::Group> objects, representing groups |
| that bugs could validly be restricted to within this product. Used mostly |
| when you need the list of all possible groups that could be set in a product |
| by anybody, disregarding whether or not the groups are active or who the |
| currently logged-in user is. |
| |
| B<Note>: This doesn't check whether or not the current user can add/remove |
| bugs to/from these groups. It just tells you that bugs I<could be in> these |
| groups, in this product. |
| |
| =item B<Params> (none) |
| |
| =item B<Returns> An arrayref of L<Bugzilla::Group> objects. |
| |
| =back |
| |
| =item C<group_is_valid> |
| |
| Returns C<1> if the passed-in L<Bugzilla::Group> or group id could be set |
| on a bug by I<anybody>, in this product. Even inactive groups are considered |
| valid. (This is a shortcut for searching L</groups_valid> to find out if |
| a group is valid in a particular product.) |
| |
| =item C<versions> |
| |
| Description: Returns all valid versions for that product. |
| |
| Params: none. |
| |
| Returns: An array of Bugzilla::Version objects. |
| |
| =item C<milestones> |
| |
| Description: Returns all valid milestones for that product. |
| |
| Params: none. |
| |
| Returns: An array of Bugzilla::Milestone objects. |
| |
| =item C<bug_count()> |
| |
| Description: Returns the total of bugs that belong to the product. |
| |
| Params: none. |
| |
| Returns: Integer with the number of bugs. |
| |
| =item C<bug_ids()> |
| |
| Description: Returns the IDs of bugs that belong to the product. |
| |
| Params: none. |
| |
| Returns: An array of integer. |
| |
| =item C<user_has_access()> |
| |
| Description: Tells you whether or not the user is allowed to enter |
| bugs into this product, based on the C<entry> group |
| control. To see whether or not a user can actually |
| enter a bug into a product, use C<$user->can_enter_product>. |
| |
| Params: C<$user> - A Bugzilla::User object. |
| |
| Returns C<1> If this user's groups allow them C<entry> access to |
| this Product, C<0> otherwise. |
| |
| =item C<flag_types()> |
| |
| Description: Returns flag types available for at least one of |
| its components. |
| |
| Params: none. |
| |
| Returns: Two references to an array of flagtype objects. |
| |
| =item C<classification()> |
| |
| Description: Returns the classification the product belongs to. |
| |
| Params: none. |
| |
| Returns: A Bugzilla::Classification object. |
| |
| =back |
| |
| =head1 SUBROUTINES |
| |
| =over |
| |
| =item C<preload> |
| |
| When passed an arrayref of C<Bugzilla::Product> objects, preloads their |
| L</milestones>, L</components>, and L</versions>, which is much faster |
| than calling those accessors on every item in the array individually. |
| |
| If the 2nd argument passed to C<preload> is true, flag types for these |
| products and their components are also preloaded. |
| |
| This function is not exported, so must be called like |
| C<Bugzilla::Product::preload($products)>. |
| |
| =back |
| |
| =head1 SEE ALSO |
| |
| L<Bugzilla::Object> |
| |
| =cut |
| |
| =head1 B<Methods in need of POD> |
| |
| =over |
| |
| =item set_allows_unconfirmed |
| |
| =item allows_unconfirmed |
| |
| =item set_name |
| |
| =item set_default_milestone |
| |
| =item set_group_controls |
| |
| =item create |
| |
| =item set_description |
| |
| =item set_is_active |
| |
| =item classification_id |
| |
| =item description |
| |
| =item default_milestone |
| |
| =item remove_from_db |
| |
| =item is_active |
| |
| =item update |
| |
| =back |
