Subversion Repositories DevTools

###############################################################################

# Codestriker: Copyright (c) 2001, 2002 David Sitsky.  All rights reserved.

# sits@users.sourceforge.net

#

# This program is free software; you can redistribute it and modify it under

# the terms of the GPL.

# Model object for handling comment data.

package Codestriker::Model::Comment;

use strict;

use Encode qw(decode_utf8);

use Codestriker::DB::DBI;

sub new {

    my $class = shift;

    my $self = {};

    $self->{id} = 0;

    $self->{topicid} = 0;

    $self->{fileline} = 0;

    $self->{filenumber} = 0;

    $self->{filenew} = 0;

    $self->{author} = '';

    $self->{data} = '';

    $self->{date} = Codestriker->get_timestamp(time);

    $self->{version} = 0;

    $self->{db_creation_ts} = "";

    $self->{db_modified_ts} = "";

    $self->{creation_ts} = "";

    $self->{modified_ts} = "";

    $self->{metrics} = undef;

    bless $self, $class;

    return $self;

}

# Create a new comment with all of the specified properties.  Ensure that the

# associated commentstate record is created/updated.

sub create {

    my ($self, $topicid, $fileline, $filenumber, $filenew, $author, $data,

	$metrics) = @_;

    my $timestamp = Codestriker->get_timestamp(time);

    # Obtain a database connection.

    my $dbh = Codestriker::DB::DBI->get_connection();

    # Check if a comment has been made against this line before.

    my $select_commentstate =

	$dbh->prepare_cached('SELECT version, id ' .

			     'FROM commentstate ' .

			     'WHERE topicid = ? AND fileline = ? AND '.

			     'filenumber = ? AND filenew = ?');

    my $success = defined $select_commentstate;

    $success &&= $select_commentstate->execute($topicid, $fileline,

					       $filenumber, $filenew);

    my $commentstateid = 0;

    my $version = 0;

    my $creation_ts = "";

    if ($success) {

	($version, $commentstateid) =

	    $select_commentstate->fetchrow_array();

	$success &&= $select_commentstate->finish();

	if (! defined $version) {

	    # A comment has not been made on this particular line yet,

	    # create the commentstate row now.  Note the old column of

	    # state has its value set to -100 so the data migration code

	    # in checksetup.pl knows this is a new row that can be

	    # ignored.

	    $creation_ts = $timestamp;

	    my $insert = $dbh->prepare_cached('INSERT INTO commentstate ' .

					      '(topicid, fileline, ' .

					      'filenumber, filenew, ' .

					      'state, version, creation_ts, ' .

					      'modified_ts) VALUES ' .

					      '(?, ?, ?, ?, ?, ?, ?, ?)');

	    $success &&= defined $insert;

	    $success &&= $insert->execute($topicid, $fileline, $filenumber,

					  $filenew, -100, 0,

					  $creation_ts, $creation_ts);

	    $success &&= $insert->finish();

	} else {

	    # Update the commentstate record.

	    my $update = $dbh->prepare_cached('UPDATE commentstate SET ' .

					      'version = ?, ' .

					      'modified_ts = ? ' .

					      'WHERE topicid = ? AND ' .

					      'fileline = ? AND ' .

					      'filenumber = ? AND ' .

					      'filenew = ?');

	    $success &&= defined $update;

	    $success &&= $update->execute(++$version,

					  $timestamp,

					  $topicid, $fileline, $filenumber,

					  $filenew);

	    $success &&= $update->finish();

	}

	# Determine the commentstateid that may have been just created.

	$success &&= $select_commentstate->execute($topicid, $fileline,

						   $filenumber, $filenew);

	if ($success) {

	    ($version, $commentstateid) = 

		$select_commentstate->fetchrow_array();

	}

	$success &&= $select_commentstate->finish();

	# Create the comment record.

	my $insert_comment =

	    $dbh->prepare_cached('INSERT INTO commentdata ' .

				 '(commentstateid, '.

				 'commentfield, author, creation_ts) ' .

				 'VALUES (?, ?, ?, ?)');

	my $success = defined $insert_comment;

	# Create the comment row.

	$success &&= $insert_comment->execute($commentstateid, $data,

					      $author, $timestamp);

	$success &&= $insert_comment->finish();

	# Now handle any commentmetric rows.

	update_comment_metrics($commentstateid, $metrics, $dbh);

    }

    $self->{id} = $commentstateid;

    $self->{topicid} =  $topicid;

    $self->{fileline} = $fileline;

    $self->{filenumber} = $filenumber;

    $self->{filenew} = $filenew;

    $self->{author} = $author;

    $self->{data} = $data;

    $self->{date} = $timestamp;

    $self->{version} = $version;

    $self->{db_creation_ts} = $creation_ts;

    $self->{creation_ts} = Codestriker->format_timestamp($creation_ts);

    $self->{db_modified_ts} = $timestamp;

    $self->{modified_ts} = Codestriker->format_timestamp($timestamp);

    # Update the metrics into the object as a hash.

    foreach my $metric (@{ $metrics }) {

	$self->{metrics}->{$metric->{name}} = $metric->{value};

    }

    # Get the filename, for the new comment.

    my $get_filename = $dbh->prepare_cached('SELECT filename ' .

					    'FROM topicfile ' .

					    'WHERE topicid = ? AND ' .

					    'sequence = ?');

    $success &&= defined $get_filename;

    $success &&= $get_filename->execute($topicid, $filenumber);

    ( $self->{filename} ) = $get_filename->fetchrow_array();

    $select_commentstate->finish();

    $get_filename->finish();

    Codestriker::DB::DBI->release_connection($dbh, $success);

    die $dbh->errstr if !$success;

}

# Update the comment metrics for a specific commentstate.  Note the rows for

# a specific metric may or may not already exist.

sub update_comment_metrics {

    my ($commentstateid, $metrics, $dbh) = @_;

    # Now create any necessary commentmetric rows.  Note its possible this

    # may refer to existing data which needs to be updated, or could be

    # new metric data.

    eval {

	if (defined $metrics) {

	    foreach my $metric (@{ $metrics }) {

		# Check if a value for this metric name has been created

		# already.

		my $select_metric =

		    $dbh->prepare_cached('SELECT COUNT(id) ' .

					 'FROM commentstatemetric ' .

					 'WHERE id = ? AND name = ?');

		$select_metric->execute($commentstateid, $metric->{name});

		my $count;

		($count) = $select_metric->fetchrow_array();

		$select_metric->finish();

		if ($count == 0) {

		    # Need to create a new row for this metric.

		    my $insert_metric =

			$dbh->prepare_cached('INSERT INTO commentstatemetric '.

					     '(id, name, value) VALUES ' .

					     '(?, ?, ?)');

		    $insert_metric->execute($commentstateid, $metric->{name},

					    $metric->{value});

		    $insert_metric->finish();

		} else {

		    # Need to update this row for this metric.

		    my $update_metric =

			$dbh->prepare_cached('UPDATE commentstatemetric ' .

					     'SET value = ? ' .

					     'WHERE id = ? AND name = ?');

		    $update_metric->execute($metric->{value}, $commentstateid,

					    $metric->{name});

		    $update_metric->finish();

		}

	    }

	}

    };

    if ($@) {

	warn "Unable to update comment state metric data because $@\n";

	eval { $dbh->rollback() };

    }

}

# This function returns as a list the authors emails address that have entered 

# comments against a topic.

sub read_authors

{

   my ($type, $topicid ) = @_;

    # Obtain a database connection.

    my $dbh = Codestriker::DB::DBI->get_connection();

    # Store the results into an array of objects.

    my @results;

    # Retrieve all of the comment information for the specified topicid.

    my $select_comment =

	$dbh->prepare_cached('SELECT distinct(commentdata.author) ' .

			     'FROM commentdata, commentstate ' .

			     'WHERE commentstate.topicid = ? AND ' .

			     'commentstate.id = commentdata.commentstateid ');

    my $success = defined $select_comment;

    my $rc = $Codestriker::OK;

    $success &&= $select_comment->execute($topicid);

    # Store the results into the referenced arrays.

    if ($success) {

	my @data;

	while (@data = $select_comment->fetchrow_array()) {

	    push @results, $data[0];

	}

	$select_comment->finish();

    }

    Codestriker::DB::DBI->release_connection($dbh, $success);

    die $dbh->errstr unless $success;

    return @results;   

}

# Return all of the comments made for a specified topic. This should only be

# called be called by the Topic object.

sub read_all_comments_for_topic($$) {

    my ($type, $topicid) = @_;

    # Obtain a database connection.

    my $dbh = Codestriker::DB::DBI->get_connection();

    # Determine if we are using Oracle, since it can't handle LEFT OUTER JOINs.

    my $using_oracle = $Codestriker::db =~ /^DBI:Oracle/i;

    # Store the results into an array of objects.

    my @results = ();

    # Retrieve all of the comment information for the specified topicid.

    my $select_comment =

	$dbh->prepare_cached('SELECT commentdata.commentfield, ' .

			     'commentdata.author, ' .

			     'commentstate.fileline, ' .

			     'commentstate.filenumber, ' .

			     'commentstate.filenew, ' .

			     'commentdata.creation_ts, ' .

			     'topicfile.filename, ' .

			     'commentstate.version, ' .

			     'commentstate.id, ' .

			     'commentstate.creation_ts, ' .

			     'commentstate.modified_ts ' .

			     'FROM commentdata, commentstate ' .

			     ($using_oracle ?

			      (', topicfile WHERE commentstate.topicid = ? ' .

			       'AND commentstate.id = commentdata.commentstateid ' .

			       'AND topicfile.topicid = commentstate.topicid(+) ' .

			       'AND topicfile.sequence = commentstate.filenumber(+) ') :

			      ('LEFT OUTER JOIN topicfile ON ' .

			       'commentstate.topicid = topicfile.topicid AND ' .

			       'commentstate.filenumber = topicfile.sequence ' .

			       'WHERE commentstate.topicid = ? ' .

			       'AND commentstate.id = commentdata.commentstateid ')) .

			     'ORDER BY ' .

			     'commentstate.filenumber, ' .

			     'commentstate.fileline, ' .

			     'commentstate.filenew, ' .

			     'commentdata.creation_ts');

    my $success = defined $select_comment;

    my $rc = $Codestriker::OK;

    $success &&= $select_comment->execute($topicid);

    # Store the results into the referenced arrays.

    if ($success) {

	my @data;

	while (@data = $select_comment->fetchrow_array()) {

	    my $comment = Codestriker::Model::Comment->new();

	    $comment->{topicid} =  $topicid;            

	    $comment->{data} = decode_utf8($data[0]);

	    $comment->{author} = $data[1];

	    $comment->{fileline} = $data[2];

	    $comment->{filenumber} = $data[3];

	    $comment->{filenew} = $data[4];

	    $comment->{date} = Codestriker->format_timestamp($data[5]);

	    $comment->{filename} = decode_utf8($data[6]);

	    $comment->{version} = $data[7];

	    $comment->{id} = $data[8];

	    $comment->{db_creation_ts} = $data[9];

	    $comment->{creation_ts} = Codestriker->format_timestamp($data[9]);

	    $comment->{db_modified_ts} = $data[10];

	    $comment->{modified_ts} = Codestriker->format_timestamp($data[10]);

	    push @results, $comment;

	}

	$select_comment->finish();

    }

    # Now for each comment returned, retrieve the comment metrics data as well.

    foreach my $comment (@results) {

	my $select_metric =

	    $dbh->prepare_cached('SELECT name, value ' .

				 'FROM commentstatemetric ' .

				 'WHERE id = ?');

	$select_metric->execute($comment->{id});

	my %metrics = ();

	my @data;

	while (@data = $select_metric->fetchrow_array()) {

	    $metrics{$data[0]} = $data[1];

	}

	$select_metric->finish();

	# Update this comment update with the list of metrics associated with

	# it.

	$comment->{metrics} = \%metrics;

    }

    Codestriker::DB::DBI->release_connection($dbh, $success);

    return @results;

}

# Return all of the comments made for a specified topic filtered by

# author and metric values.  If a filter parameter is not defined, then

# it is ignored.

sub read_filtered {

    my ($type, $topicid, $filtered_by_author, $metric_filter) = @_;

    my %metric_filter = %{ $metric_filter };

    # Read all of the comments from the database. 

    my @comments = $type->read_all_comments_for_topic($topicid);

    # Now filter out comments that don't match the author and metric 

    # filter.

    @comments = grep { 

        my $comment = $_;

        my $keep_comment = 1;

        # Check for filters via the comment author name, handle email

        # SPAM filtering.

        my $filteredAuthor =

            	    Codestriker->filter_email($comment->{author});

        my $filteredByAuthor =

            	    Codestriker->filter_email($filtered_by_author);

        if ($filteredByAuthor ne "" && $filteredAuthor ne $filteredByAuthor) {

	    # Don't keep this record.

	    $keep_comment = 0;

	}

	else {

	    # Check if the metric values match for each key.

	    foreach my $metric (keys %metric_filter) {

		if ($comment->{metrics}->{$metric} ne

		    $metric_filter{$metric}) {

		    $keep_comment = 0;

		    last;

		}

	    }

	}

	# Indicate whether this comment should be kept or not.

 	$keep_comment;

    } @comments;

    return @comments;

}

# Update the specified metric for the specified commentstate.  The version

# parameter indicates what version of the commentstate the user was operating

# on.

sub change_state {

    my ($self, $metric_name, $metric_value, $version) = @_;

    # Obtain a database connection.

    my $dbh = Codestriker::DB::DBI->get_connection();

    my $timestamp = Codestriker->get_timestamp(time);   

    # Check that the version reflects the current version in the DB.

    my $select_comments =

	$dbh->prepare_cached('SELECT id, version ' .

			     'FROM commentstate ' .

			     'WHERE topicid = ? AND fileline = ? AND ' .

			     'filenumber = ? AND filenew = ?');

    my $update_comments =

	$dbh->prepare_cached('UPDATE commentstate SET version = ?, ' .

			     'modified_ts = ? ' .

			     'WHERE id = ?');

    my $success = defined $select_comments && defined $update_comments;

    my $rc = $Codestriker::OK;

    # Retrieve the current comment data.

    $success &&= $select_comments->execute($self->{topicid}, 

     				           $self->{fileline},

                                           $self->{filenumber},

					   $self->{filenew});

    # Make sure that the topic still exists, and is therefore valid.

    my ($id, $current_version);

    if ($success && 

	! (($id, $current_version)

	   = $select_comments->fetchrow_array())) {

	# Invalid topic id.

	$success = 0;

	$rc = $Codestriker::INVALID_TOPIC;

    }

    $success &&= $select_comments->finish();

    # Check the version number.

    if ($success && $version != $self->{version}) {

	$success = 0;

	$rc = $Codestriker::STALE_VERSION;

    }

    # Now update the version number for commentstate.

    $self->{version} = $self->{version} + 1;

    $self->{metrics}->{$metric_name} = $metric_value;

    $self->{modified_ts} = Codestriker->format_timestamp($timestamp);

    $success &&= $update_comments->execute($self->{version},

					   $timestamp,

					   $id);

    # Now update the commentstatemetric row for this metric.

    my $metrics = [ { name => $metric_name, value => $metric_value } ];

    update_comment_metrics($id, $metrics, $dbh);

    Codestriker::DB::DBI->release_connection($dbh, $success);

    return $rc;

}

1;