480 lines
14 KiB
Perl
480 lines
14 KiB
Perl
# -*- 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 Testopia System.
|
|
#
|
|
# The Initial Developer of the Original Code is Greg Hendricks.
|
|
# Portions created by Greg Hendricks are Copyright (C) 2006
|
|
# Novell. All Rights Reserved.
|
|
#
|
|
# Contributor(s): Greg Hendricks <ghendricks@novell.com>
|
|
|
|
package Testopia::Product;
|
|
|
|
use strict;
|
|
|
|
# Extends Bugzilla::Product;
|
|
use base "Bugzilla::Product";
|
|
|
|
use Bugzilla;
|
|
|
|
sub environments {
|
|
my $self = shift;
|
|
my($active, $current) = @_;
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
return $self->{'environments'} if defined $self->{'environments'};
|
|
|
|
require Testopia::Environment;
|
|
|
|
my $query = "SELECT environment_id";
|
|
$query .= " FROM test_environments";
|
|
$query .= " WHERE product_id = ?";
|
|
$query .= " AND isactive = 1 OR environment_id = ?" if $active;
|
|
|
|
my $ref;
|
|
if ($active && $current){
|
|
$ref = $dbh->selectcol_arrayref($query, undef, ($self->{'id'}, $current));
|
|
}
|
|
else{
|
|
$ref = $dbh->selectcol_arrayref($query, undef, $self->{'id'});
|
|
}
|
|
|
|
my @objs;
|
|
foreach my $id (@{$ref}){
|
|
push @objs, Testopia::Environment->new($id);
|
|
}
|
|
|
|
$self->{'environments'} = \@objs;
|
|
return $self->{'environments'};
|
|
}
|
|
|
|
sub builds {
|
|
my $self = shift;
|
|
my($active, $current) = @_;
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
require Testopia::Build;
|
|
|
|
my $query = "SELECT build_id FROM test_builds WHERE product_id = ?";
|
|
if ($active && $current){
|
|
$query .= " AND isactive = 1 OR build_id = ?";
|
|
}
|
|
elsif ($active){
|
|
$query .= " AND isactive = 1";
|
|
}
|
|
$query .= " ORDER BY name";
|
|
|
|
my $ref;
|
|
if ($active && $current){
|
|
$ref = $dbh->selectcol_arrayref($query, undef, ($self->{'id'}, $current));
|
|
}
|
|
elsif ($active){
|
|
$ref = $dbh->selectcol_arrayref($query, undef, $self->{'id'});
|
|
}
|
|
else{
|
|
$ref = $dbh->selectcol_arrayref($query, undef, $self->{'id'});
|
|
}
|
|
|
|
my @objs;
|
|
foreach my $id (@{$ref}){
|
|
push @objs, Testopia::Build->new($id);
|
|
}
|
|
|
|
$self->{'builds'} = \@objs;
|
|
return $self->{'builds'};
|
|
}
|
|
|
|
sub categories {
|
|
my $self = shift;
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
my $ref = $dbh->selectcol_arrayref(
|
|
"SELECT category_id
|
|
FROM test_case_categories
|
|
WHERE product_id = ?
|
|
ORDER BY name",
|
|
undef, $self->{'id'});
|
|
my @objs;
|
|
require Testopia::Category;
|
|
foreach my $id (@{$ref}){
|
|
push @objs, Testopia::Category->new($id);
|
|
}
|
|
$self->{'categories'} = \@objs;
|
|
return $self->{'categories'};
|
|
}
|
|
|
|
sub plans {
|
|
my $self = shift;
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
return $self->{'plans'} if exists $self->{'plans'};
|
|
|
|
require Testopia::TestPlan;
|
|
|
|
my $ref = $dbh->selectcol_arrayref(
|
|
"SELECT plan_id
|
|
FROM test_plans
|
|
WHERE product_id = ?
|
|
ORDER BY name",
|
|
undef, $self->{'id'});
|
|
my @objs;
|
|
|
|
foreach my $id (@{$ref}){
|
|
push @objs, Testopia::TestPlan->new($id);
|
|
}
|
|
$self->{'plans'} = \@objs;
|
|
return $self->{'plans'};
|
|
}
|
|
|
|
sub cases {
|
|
my ($self) = @_;
|
|
my $dbh = Bugzilla->dbh;
|
|
return $self->{'cases'} if exists $self->{'cases'};
|
|
|
|
require Testopia::TestCase;
|
|
|
|
my $caseids = $dbh->selectcol_arrayref(
|
|
"SELECT case_id FROM test_case_plans
|
|
INNER JOIN test_plans on test_case_plans.plan_id = test_plans.plan_id
|
|
WHERE test_plans.product_id = ?",
|
|
undef, $self->id);
|
|
|
|
my @cases;
|
|
foreach my $id (@{$caseids}){
|
|
push @cases, Testopia::TestCase->new($id);
|
|
}
|
|
|
|
$self->{'cases'} = \@cases;
|
|
return $self->{'cases'};
|
|
}
|
|
|
|
sub runs {
|
|
my ($self) = @_;
|
|
my $dbh = Bugzilla->dbh;
|
|
return $self->{'runs'} if exists $self->{'runs'};
|
|
|
|
require Testopia::TestRun;
|
|
|
|
my $runids = $dbh->selectcol_arrayref(
|
|
"SELECT run_id FROM test_runs
|
|
INNER JOIN test_plans ON test_runs.plan_id = test_plans.plan_id
|
|
WHERE test_plans.product_id = ?",
|
|
undef, $self->id);
|
|
|
|
my @runs;
|
|
foreach my $id (@{$runids}){
|
|
push @runs, Testopia::TestRun->new($id);
|
|
}
|
|
|
|
$self->{'runs'} = \@runs;
|
|
return $self->{'runs'};
|
|
}
|
|
|
|
sub environment_categories {
|
|
my $self = shift;
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
my $ref = $dbh->selectcol_arrayref(
|
|
"SELECT env_category_id
|
|
FROM test_environment_category
|
|
WHERE product_id = ?",
|
|
undef, $self->id);
|
|
my @objs;
|
|
require Testopia::Environment::Category;
|
|
foreach my $id (@{$ref}){
|
|
push @objs, Testopia::Environment::Category->new($id);
|
|
}
|
|
$self->{'environment_categories'} = \@objs;
|
|
return $self->{'environment_categories'};
|
|
}
|
|
|
|
sub check_product_by_name {
|
|
my $self = shift;
|
|
my ($name) = @_;
|
|
my $dbh = Bugzilla->dbh;
|
|
my ($used) = $dbh->selectrow_array(qq{
|
|
SELECT id
|
|
FROM products
|
|
WHERE name = ?},undef,$name);
|
|
return $used;
|
|
}
|
|
|
|
sub versions {
|
|
my $self = shift;
|
|
my ($byid) = shift;
|
|
my $id = $byid ? 'id' : 'value';
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
my $values = $dbh->selectall_arrayref(
|
|
"SELECT $id AS id, value AS name
|
|
FROM versions
|
|
WHERE product_id = ?
|
|
ORDER BY value", {'Slice' =>{}}, $self->id);
|
|
|
|
$self->{'versions'} = $values;
|
|
return $self->{'versions'};
|
|
}
|
|
|
|
sub milestones {
|
|
my $self = shift;
|
|
my ($byid) = shift;
|
|
my $id = $byid ? 'id' : 'value';
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
my $values = $dbh->selectall_arrayref(
|
|
"SELECT $id AS id, value AS name
|
|
FROM milestones
|
|
WHERE product_id = ?
|
|
ORDER BY value", {'Slice' =>{}}, $self->id);
|
|
|
|
$self->{'milestones'} = $values;
|
|
return $self->{'milestones'};
|
|
}
|
|
|
|
sub tags {
|
|
my $self = shift;
|
|
my $dbh = Bugzilla->dbh;
|
|
|
|
require Testopia::TestTag;
|
|
|
|
my $ref = $dbh->selectcol_arrayref(
|
|
"(SELECT test_tags.tag_id, test_tags.tag_name AS name
|
|
FROM test_tags
|
|
INNER JOIN test_case_tags ON test_tags.tag_id = test_case_tags.tag_id
|
|
INNER JOIN test_cases on test_cases.case_id = test_case_tags.case_id
|
|
INNER JOIN test_case_plans on test_case_plans.case_id = test_cases.case_id
|
|
INNER JOIN test_plans ON test_plans.plan_id = test_case_plans.plan_id
|
|
WHERE test_plans.product_id = ?)
|
|
UNION
|
|
(SELECT test_tags.tag_id, test_tags.tag_name AS name
|
|
FROM test_tags
|
|
INNER JOIN test_plan_tags ON test_plan_tags.tag_id = test_tags.tag_id
|
|
INNER JOIN test_plans ON test_plan_tags.plan_id = test_plans.plan_id
|
|
WHERE test_plans.product_id = ?)
|
|
UNION
|
|
(SELECT test_tags.tag_id, test_tags.tag_name AS name
|
|
FROM test_tags
|
|
INNER JOIN test_run_tags ON test_run_tags.tag_id = test_tags.tag_id
|
|
INNER JOIN test_runs ON test_runs.run_id = test_run_tags.run_id
|
|
INNER JOIN test_plans ON test_plans.plan_id = test_runs.plan_id
|
|
WHERE test_plans.product_id = ?)
|
|
ORDER BY name", undef, ($self->id,$self->id,$self->id));
|
|
|
|
my @product_tags;
|
|
foreach my $id (@$ref){
|
|
push @product_tags, Testopia::TestTag->new($id);
|
|
}
|
|
|
|
$self->{'tags'} = \@product_tags;
|
|
return $self->{'tags'};
|
|
}
|
|
|
|
sub type {
|
|
my $self = shift;
|
|
$self->{'type'} = 'product';
|
|
return $self->{'type'};
|
|
}
|
|
|
|
sub canview {
|
|
my $self = shift;
|
|
my ($user) = @_;
|
|
$user ||= Bugzilla->user;
|
|
return 1 if $user->can_see_product($self->name);
|
|
return 0;
|
|
}
|
|
|
|
sub canedit {
|
|
my $self = shift;
|
|
my ($user) = @_;
|
|
$user ||= Bugzilla->user;
|
|
return 1 if $user->in_group('Testers') && $user->can_see_product($self->name);
|
|
return 0;
|
|
}
|
|
|
|
sub TO_JSON {
|
|
my $self = shift;
|
|
my $obj;
|
|
my $json = new JSON;
|
|
|
|
foreach my $field ($self->DB_COLUMNS){
|
|
$field =~ s/product\.//;
|
|
$obj->{$field} = $self->{$field};
|
|
}
|
|
|
|
# Add the calculated fields
|
|
$obj->{'type'} = $self->type;
|
|
$obj->{'id'} = $self->id;
|
|
$obj->{'canedit'} = $self->canedit;
|
|
|
|
return $json->encode($obj);
|
|
}
|
|
|
|
1;
|
|
|
|
__END__
|
|
|
|
=head1 NAME
|
|
|
|
Testopia::Product
|
|
|
|
=head1 EXTENDS
|
|
|
|
Bugzilla::Product
|
|
|
|
=head1 DESCRIPTION
|
|
|
|
Provides additional methods and functionality to Bugzilla products
|
|
for Testopia specific usage. Methods are read only. For updating and
|
|
creating new products, see Bugzilla::Product.
|
|
|
|
=head1 SYNOPSIS
|
|
|
|
=head2 Creating
|
|
|
|
$build = Testopia::Product->new($product_id);
|
|
$build = Testopia::Product->new({name => $name});
|
|
|
|
=head1 METHODS
|
|
|
|
=over
|
|
|
|
=item C<builds($active, $current)>
|
|
|
|
Description: Get the list of builds associated with this product.
|
|
|
|
Params: $active - Boolean (optional): True to only include builds with isactive set.
|
|
Defaults to False.
|
|
$current - Integer (optional): Must be used in conjuntion with $active.
|
|
If $active is true then $current should be the current build
|
|
selected to prevent it from being excluded if isactive is false.
|
|
|
|
Returns: Array: Returns an array of Build objects.
|
|
|
|
=item C<get_cases($product)>
|
|
|
|
Description: Get the list of cases associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of TestCase objects.
|
|
|
|
=item C<get_categories($product)>
|
|
|
|
Description: Get the list of categories associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of Case Category objects.
|
|
|
|
=item C<get_components($product)>
|
|
|
|
Description: Get the list of components associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of Component objects.
|
|
|
|
=item C<get_environments($product)>
|
|
|
|
Description: Get the list of environments associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of Environment objects.
|
|
|
|
=item C<get_milestones($product)>
|
|
|
|
Description: Get the list of milestones associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of Milestone objects.
|
|
|
|
=item C<get_plans($product)>
|
|
|
|
Description: Get the list of plans associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of Test Plan objects.
|
|
|
|
=item C<get_runs($product)>
|
|
|
|
Description: Get the list of runs associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of Test Run objects.
|
|
|
|
=item C<get_tags($product)>
|
|
|
|
Description: Get the list of tags associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of Tags objects.
|
|
|
|
=item C<get_versions($product)>
|
|
|
|
Description: Get the list of versions associated with this product.
|
|
|
|
Params: $product - Integer/String/Object
|
|
Integer: product_id of the product in the Database
|
|
String: Product name
|
|
Object: Blessed Bugzilla::Product object
|
|
|
|
Returns: Array: Returns an array of Version objects.
|
|
|
|
=item C<lookup_name_by_id> B<DEPRECATED> Use Product::get instead
|
|
|
|
=item C<lookup_id_by_name> B<DEPRECATED - CONSIDERED HARMFUL> Use Product::check_product instead
|
|
|
|
=back
|
|
|
|
=head1 SEE ALSO
|
|
|
|
=over
|
|
|
|
L<Testopia::Product>
|
|
|
|
L<Bugzilla::Webservice>
|
|
|
|
=back
|
|
|
|
=head1 AUTHOR
|
|
|
|
Greg Hendricks <ghendricks@novell.com> |