# -*- 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 Netscape Communications # Corporation. Portions created by Netscape are # Copyright (C) 1998 Netscape Communications Corporation. All # Rights Reserved. # # Contributor(s): Gervase Markham <gerv@gerv.net> use strict; use lib "."; # This module implements a series - a set of data to be plotted on a chart. # # This Series is in the database if and only if self->{'series_id'} is defined. # Note that the series being in the database does not mean that the fields of # this object are the same as the DB entries, as the object may have been # altered. package Bugzilla::Series; use Bugzilla; use Bugzilla::Util; use Bugzilla::User; use constant PUBLIC_USER_ID => 0; sub new { my $invocant = shift; my $class = ref($invocant) || $invocant; # Create a ref to an empty hash and bless it my $self = {}; bless($self, $class); my $arg_count = scalar(@_); # There are three ways of creating Series objects. Two (CGI and Parameters) # are for use when creating a new series. One (Database) is for retrieving # information on existing series. if ($arg_count == 1) { if (ref($_[0])) { # We've been given a CGI object to create a new Series from. # This series may already exist - external code needs to check # before it calls writeToDatabase(). $self->initFromCGI($_[0]); } else { # We've been given a series_id, which should represent an existing # Series. $self->initFromDatabase($_[0]); } } elsif ($arg_count >= 6 && $arg_count <= 8) { # We've been given a load of parameters to create a new Series from. # Currently, undef is always passed as the first parameter; this allows # you to call writeToDatabase() unconditionally. $self->initFromParameters(@_); } else { die("Bad parameters passed in - invalid number of args: $arg_count"); } return $self; } sub initFromDatabase { my $self = shift; my $series_id = shift; &::detaint_natural($series_id) || &::ThrowCodeError("invalid_series_id", { 'series_id' => $series_id }); my $dbh = Bugzilla->dbh; my @series = $dbh->selectrow_array("SELECT series.series_id, cc1.name, " . "cc2.name, series.name, series.creator, series.frequency, " . "series.query " . "FROM series " . "LEFT JOIN series_categories AS cc1 " . " ON series.category = cc1.category_id " . "LEFT JOIN series_categories AS cc2 " . " ON series.subcategory = cc2.category_id " . "WHERE series.series_id = $series_id"); if (@series) { # Note that we calculate $self->{'public'} ourselves instead of passing # it as the last parameter in @series; this is because isSubscribed() # requires the rest of the object to be set up correctly. $self->initFromParameters(@series); $self->{'public'} = $self->isSubscribed(PUBLIC_USER_ID); } else { &::ThrowCodeError("invalid_series_id", { 'series_id' => $series_id }); } } sub initFromParameters { # Pass undef as the first parameter if you are creating a new series. my $self = shift; ($self->{'series_id'}, $self->{'category'}, $self->{'subcategory'}, $self->{'name'}, $self->{'creator'}, $self->{'frequency'}, $self->{'query'}, $self->{'public'}) = @_; } sub initFromCGI { my $self = shift; my $cgi = shift; $self->{'series_id'} = $cgi->param('series_id') || undef; if (defined($self->{'series_id'})) { detaint_natural($self->{'series_id'}) || &::ThrowCodeError("invalid_series_id", { 'series_id' => $self->{'series_id'} }); } $self->{'category'} = $cgi->param('category') || $cgi->param('newcategory') || &::ThrowUserError("missing_category"); $self->{'subcategory'} = $cgi->param('subcategory') || $cgi->param('newsubcategory') || &::ThrowUserError("missing_subcategory"); $self->{'name'} = $cgi->param('name') || &::ThrowUserError("missing_name"); $self->{'creator'} = Bugzilla->user->id; $self->{'frequency'} = $cgi->param('frequency'); detaint_natural($self->{'frequency'}) || &::ThrowUserError("missing_frequency"); $self->{'query'} = $cgi->canonicalise_query("format", "ctype", "action", "category", "subcategory", "name", "frequency", "public", "query_format"); $self->{'public'} = $cgi->param('public') ? 1 : 0; } sub writeToDatabase { my $self = shift; my $dbh = Bugzilla->dbh; $dbh->do("LOCK TABLES series_categories WRITE, series WRITE, " . "user_series_map WRITE"); my $category_id = getCategoryID($self->{'category'}); my $subcategory_id = getCategoryID($self->{'subcategory'}); my $exists; if ($self->{'series_id'}) { $exists = $dbh->selectrow_array("SELECT series_id FROM series WHERE series_id = $self->{'series_id'}"); } # Is this already in the database? if ($exists) { # Update existing series my $dbh = Bugzilla->dbh; $dbh->do("UPDATE series SET " . "category = ?, subcategory = ?," . "name = ?, frequency = ? " . "WHERE series_id = ?", undef, $category_id, $subcategory_id, $self->{'name'}, $self->{'frequency'}, $self->{'series_id'}); } else { # Insert the new series into the series table trick_taint($self->{'query'}); $dbh->do("INSERT INTO series (creator, category, subcategory, " . "name, frequency, query) VALUES ($self->{'creator'}, " . "$category_id, $subcategory_id, " . $dbh->quote($self->{'name'}) . ", $self->{'frequency'}," . $dbh->quote($self->{'query'}) . ")"); # Retrieve series_id $self->{'series_id'} = $dbh->selectrow_array("SELECT MAX(series_id) " . "FROM series"); $self->{'series_id'} || &::ThrowCodeError("missing_series_id", { 'series' => $self }); # Subscribe creator to the newly-created series. $self->subscribe($self->{'creator'}); } # Update publicness by changing subscription if ($self->{'public'}) { $self->subscribe(PUBLIC_USER_ID); } else { $self->unsubscribe(PUBLIC_USER_ID); } $dbh->do("UNLOCK TABLES"); } # Check whether a series with this name, category and subcategory exists in # the DB and, if so, returns its series_id. sub existsInDatabase { my $self = shift; my $dbh = Bugzilla->dbh; my $category_id = getCategoryID($self->{'category'}); my $subcategory_id = getCategoryID($self->{'subcategory'}); trick_taint($self->{'name'}); my $series_id = $dbh->selectrow_array("SELECT series_id " . "FROM series WHERE category = $category_id " . "AND subcategory = $subcategory_id AND name = " . $dbh->quote($self->{'name'})); return($series_id); } # Get a category or subcategory IDs, creating the category if it doesn't exist. sub getCategoryID { my ($category) = @_; my $category_id; my $dbh = Bugzilla->dbh; # This seems for the best idiom for "Do A. Then maybe do B and A again." while (1) { # We are quoting this to put it in the DB, so we can remove taint trick_taint($category); $category_id = $dbh->selectrow_array("SELECT category_id " . "from series_categories " . "WHERE name =" . $dbh->quote($category)); last if $category_id; $dbh->do("INSERT INTO series_categories (name) " . "VALUES (" . $dbh->quote($category) . ")"); } return $category_id; } sub subscribe { my $self = shift; my $userid = shift; if (!$self->isSubscribed($userid)) { # Subscribe current user to series_id my $dbh = Bugzilla->dbh; $dbh->do("INSERT INTO user_series_map " . "VALUES($userid, $self->{'series_id'})"); } } sub unsubscribe { my $self = shift; my $userid = shift; if ($self->isSubscribed($userid)) { # Remove current user's subscription to series_id my $dbh = Bugzilla->dbh; $dbh->do("DELETE FROM user_series_map " . "WHERE user_id = $userid AND series_id = $self->{'series_id'}"); } } sub isSubscribed { my $self = shift; my $userid = shift; my $dbh = Bugzilla->dbh; my $issubscribed = $dbh->selectrow_array("SELECT 1 FROM user_series_map " . "WHERE user_id = $userid " . "AND series_id = $self->{'series_id'}"); return $issubscribed; } 1;