Subversion Repositories DevTools

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

# Copyright (c) 2003 Jason Remillard.  All rights reserved.

#

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

# the terms of the GPL.

# Model object for handling metric data.

package Codestriker::Model::Metrics;

use strict;

use Encode qw(decode_utf8);

use Codestriker::DB::DBI;

sub new {

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

    my $self = {};

    $self->{topicmetrics} = undef;

    $self->{topicid} = $topicid;

    $self->{usermetrics} = {};

    $self->{topichistoryrows} = undef;

    bless $self, $class;

    return $self;

}

# Sets the topic metrics values. The values are passed in as an

# array. The array must be in the same order returned by

# get_topic_metric(). Metrics that are bad are silently not stored.

sub set_topic_metrics {

    my ($self,@metric_values) = @_;

    my @metrics = $self->get_topic_metrics();

    for (my $index = 0; $index < scalar(@metrics); ++$index) {

	next if ($metrics[$index]->{enabled} == 0);

	die "error: not enough metrics" if (scalar(@metric_values) == 0);

	my $value = shift @metric_values;

	if ($self->_verify_metric($metrics[$index], $value) eq '') {

	    $metrics[$index]->{value} = $value;

	}

    }

}

# Verifies that all of the topic metrics are well formed and valid. It will

# return a non-empty string if a problem is found.

sub verify_topic_metrics {

    my ($self,@metric_values) = @_;

    my $msg = '';

    my @metrics = $self->get_topic_metrics();

    for (my $index = 0; $index < scalar(@metrics); ++$index) {

	next if ($metrics[$index]->{enabled} == 0);

	# Disabled values may be in the database (somebody turned off

	# the metrics).  However, they are not paramters so the index

	# between the paramters and the metrics objects will not

	# match.

	my $value = shift @metric_values;

	$msg .= $self->_verify_metric($metrics[$index], $value);

    }

    return $msg;

}

# Returns the topic metrics as a collection of references to

# hashs. The hash that is returned has the same keys as the

# metrics_schema hash, plus a value key. If the user has not entered a

# value, it will be set to an empty string.

sub get_topic_metrics {

    my $self = shift;

    my @topic_metrics;

    if (defined($self->{topicmetrics})) {

	# The topic metrics have already been loaded from the

	# database, just return the cached data.

	@topic_metrics = @{$self->{topicmetrics}};

    }

    else {

	my @stored_metrics = ();

	if (defined($self->{topicid})) {

	    # Obtain a database connection.

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

	    my $select_topic_metrics = 

		$dbh->prepare_cached('SELECT topicmetric.metric_name, 

					     topicmetric.value ' .

				     'FROM topicmetric ' .

		                     'WHERE topicmetric.topicid = ?');

	    $select_topic_metrics->execute($self->{topicid}); 

	    @stored_metrics = @{$select_topic_metrics->fetchall_arrayref()};

	    # Close the connection, and check for any database errors.

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

	}

	# Match the configured metrics to the metrics in the database. If 

	# the configured metric is found in the database, it is removed 

	# from the stored_metric list to find any data that is in the 

	# database, but is not configured.

	foreach my $metric_schema (Codestriker::get_metric_schema()) {

	    if ($metric_schema->{scope} eq 'topic') {

		my $metric =

		    { # This is the topic metric.

		    name        => $metric_schema->{name},

		    description => $metric_schema->{description},

		    value       => '',

		    filter      => $metric_schema->{filter},

		    enabled     => $metric_schema->{enabled},

		    in_database => 0

		    };

		for (my $index = 0; $index < scalar(@stored_metrics); ++$index) {

		    my $stored_metric = $stored_metrics[$index];

		    if ($stored_metric->[0] eq $metric_schema->{name}) {

			$metric->{value} = $stored_metric->[1];

			$metric->{in_database} = 1;

			splice @stored_metrics, $index, 1;

			last;

		    }

		}

		if ($metric_schema->{enabled} || $metric->{in_database}) {

		    push @topic_metrics, $metric;

		}

	    }

	}

	# Add in any metrics that are in the database but not

	# currently configured.  The system should display the

	# metrics, but not let the user modify them.

	for (my $index = 0; $index < scalar(@stored_metrics); ++$index) {

	    my $stored_metric = $stored_metrics[$index];

	    # This is the topic metric.

	    my $metric =

		{

		name         => $stored_metric->[0],

		description  => '',

		value        => $stored_metric->[1],

		# User can not change the metric, not configured.

		enabled      => 0,

		in_database  => 1

		};

	    push @topic_metrics, $metric;

	}

	push @topic_metrics, $self->_get_built_in_topic_metrics();

	$self->{topicmetrics} = \@topic_metrics;

    }

    return @topic_metrics;

}

# Get just the list of users that have actually looked at the review. This is

# used on the main page to out users that are not doing the reviews when invited.

sub get_list_of_actual_topic_participants {

    my ($self) = @_;

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

    my $actual_user_list_ref = 

         $dbh->selectall_arrayref(

	        'SELECT DISTINCT LOWER(email) FROM topicviewhistory ' .

	        'WHERE topicid = ?',{}, $self->{topicid});

    my @actual_user_list = ();

    foreach my $user ( @$actual_user_list_ref ) {

        push @actual_user_list,$user->[0] if defined $user->[0] && $user->[0] ne "";

    }

    # Close the connection, and check for any database errors.

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

    return @actual_user_list;

}

# Get a list of users that have metric data for this topic. People can 

# look at the topic even if they were not invited, so if somebody touches the 

# topic, they will appear in this list. Using this function rather than the 

# invite list from the topic will insure that people don't get missed from 

# the metric data.

sub get_complete_list_of_topic_participants {

    my ($self) = @_;

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

    my @metric_user_list = @{ $dbh->selectall_arrayref('

	    SELECT distinct LOWER(email) 

	    from participant WHERE topicid = ?',{}, $self->{topicid})};

    push @metric_user_list, @{ $dbh->selectall_arrayref('

	    SELECT LOWER(author) FROM topic WHERE id = ?',{}, $self->{topicid})};

    push @metric_user_list, @{ $dbh->selectall_arrayref('

	    SELECT DISTINCT LOWER(email) FROM topicusermetric 

	    WHERE topicid = ?',{}, $self->{topicid})};

    push @metric_user_list, @{ $dbh->selectall_arrayref(

	    'SELECT DISTINCT LOWER(author) FROM commentdata, commentstate ' .

	    'WHERE commentstate.topicid = ? AND

		   commentstate.id = commentdata.commentstateid ',

		   {}, $self->{topicid})};

    push @metric_user_list, @{ $dbh->selectall_arrayref(

	    'SELECT DISTINCT LOWER(email) FROM topicviewhistory ' .

	    'WHERE topicid = ? AND email IS NOT NULL',{}, $self->{topicid})};

    # remove the duplicates.

    my %metric_user_hash;

    foreach my $user (@metric_user_list) {

	$metric_user_hash{$user->[0]} = 1;

    }

    # Need to sort the empty user name last so that the template parameters 

    # that are done by index don't start at 1, and therefor not allow users

    # to save the metrics.

    @metric_user_list = sort { 

        return 1  if ( $a eq "");

        return -1 if ( $b eq "");

        return $a cmp $b; 

    } keys %metric_user_hash;

    # Close the connection, and check for any database errors.

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

    return @metric_user_list;

}

# Get a list of users that are invited for this review.

sub get_list_of_topic_participants {

    my ($self) = @_;

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

    my @metric_user_list = @{ $dbh->selectall_arrayref('

	    SELECT distinct LOWER(email) 

	    from participant WHERE topicid = ?',{}, $self->{topicid})};

    push @metric_user_list, @{ $dbh->selectall_arrayref('

	    SELECT LOWER(author) FROM topic WHERE id = ?',{}, $self->{topicid})};

    # remove the duplicates.

    my %metric_user_hash;

    foreach my $user (@metric_user_list) {

	$metric_user_hash{$user->[0]} = 1;

    }

    # Need to sort the empty user name last so that the template parameters 

    # that are done by index don't start at 1, and therefor not allow users

    # to save the metrics.

    @metric_user_list = sort { 

        return 1  if ( $a eq "");

        return -1 if ( $b eq "");

        return $a cmp $b; 

    } keys %metric_user_hash;

    # Close the connection, and check for any database errors.

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

    return @metric_user_list;

}

# Sets the metrics for a specific user, both authors and reviewers. cc's don't 

# get metrics. The metrics are sent in as an array, that must in the same 

# order as the get_user_metric() call returns them. Metrics that are bad are 

# silently not stored.

sub set_user_metric {

    my ($self, $user, @metric_values) = @_;

    my @metrics = $self->get_user_metrics($user);

    for (my $index = 0; $index < scalar(@metrics); ++$index) {

	next if ($metrics[$index]->{enabled} == 0);

	die "error: not enough metrics" if (scalar(@metric_values) == 0);

	# Disabled values may be in the database (somebody turned off

	# the metrics).  However, they are not paramters so the index

	# between the paramters and the metrics objects will not

	# match.

	my $value = shift @metric_values;

	if ($self->_verify_metric($metrics[$index], $value) eq '') {

	    $metrics[$index]->{value} = $value

	}

    }

}

# Verifies that all of the user metrics are well formed and valid inputs. If a 

# problem is found the function will return a non-empty string.

sub verify_user_metrics {

    my ($self, $user, @metric_values) = @_;

    my $msg = '';

    my @metrics = $self->get_user_metrics($user);

    for (my $index = 0; $index < scalar(@metrics); ++$index) {

	next if ($metrics[$index]->{enabled} == 0);

	# Disabled values may be in the database (somebody turned off

	# the metrics).  However, they are not paramters so the index

	# between the paramters and the metrics objects will not

	# match.

	my $value = shift @metric_values;

	$msg .= $self->_verify_metric($metrics[$index], $value);

    }

    return $msg;

}

# Returns the user metrics as a collection of references to hashs. The

# hash that is returned has the same keys as the metrics_schema hash,

# plus a value key. If the user has not entered a value, it will be

# set to an empty string.

sub get_user_metrics {

    my ($self, $username) = @_;

    my @user_metrics;

    if (exists($self->{usermetrics}->{$username})) {

	# If the metrics for this user has already been loaded from

	# the database, return the cached result of that load.

	@user_metrics = @{$self->{usermetrics}->{$username}};

    }

    else {    

	my @stored_metrics = ();

	if (defined($self->{topicid})) {

	    # Obtain a database connection.

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

	    # Get all of the user outputs for this topic regardless of

	    # the user.

	    my $selected_all_user_metrics = 

		$dbh->prepare_cached('SELECT DISTINCT metric_name ' .

				     'FROM topicusermetric ' .

				     'WHERE topicid = ? ' .

				     'ORDER BY metric_name');

	    $selected_all_user_metrics->execute($self->{topicid}); 

	    @stored_metrics =

		@{$selected_all_user_metrics->fetchall_arrayref()};

	    # Get the outputs for this user.

	    my $select_user_metrics = 

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

				     'FROM topicusermetric ' .

				     'WHERE topicid = ? AND LOWER(email) = LOWER(?) ' .

				     'ORDER BY metric_name');

	    $select_user_metrics->execute($self->{topicid}, $username);

	    my @user_stored_metrics =

		@{$select_user_metrics->fetchall_arrayref()};

	    # Stuff the complete list with the values from the current

	    # user list.  Handle displaying metrics that are in the

	    # db, but not enabled for new topics.

	    foreach my $metric (@stored_metrics) {

		my $foundit = 0;

		foreach my $user_metric (@user_stored_metrics) {

		    if ($user_metric->[0] eq $metric->[0]) {

			$foundit = 1;

			push @$metric, $user_metric->[1];

			last;

		    }

		}

		if ($foundit == 0) {

		    push @$metric,'';

		}

	    }

	    # Close the connection, and check for any database errors.

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

	}

	foreach my $metric_schema (Codestriker::get_metric_schema()) {

	    if ($metric_schema->{scope} ne 'topic') {

		my $metric = 

		{ 

		    name        => $metric_schema->{name},

		    description => $metric_schema->{description},

		    value       => '',

		    enabled     => $metric_schema->{enabled},

		    scope       => $metric_schema->{scope},

		    filter      => $metric_schema->{filter},

		};

		for (my $index = 0; $index < scalar(@stored_metrics);

		     ++$index) {

		    my $stored_metric = $stored_metrics[$index];

		    if ($stored_metric->[0] eq $metric_schema->{name}) {

			$metric->{value} = $stored_metric->[1];

			$metric->{in_database} = 1;

			splice @stored_metrics, $index,1;

			last;

		    }

		}

		if ($metric_schema->{enabled} || $metric->{in_database}) {

                    if ($username eq "") {

                        # don't let any metrics be set into the db for unknown users.

                        $metric->{enabled} = 0;

                    }

		    push @user_metrics, $metric;

		}

	    }

	}

	# Clean up any metrics that are in the database but not in the

	# schema, we will not let them change them, and we don't have

	# the description anymore.

	for (my $index = 0; $index < scalar(@stored_metrics); ++$index) {

	    my $stored_metric = $stored_metrics[$index];

	    my $metric =

		{ # this is the topic metric  

		name=>$stored_metric->[0],

		description=>'',

		value=>$stored_metric->[1],

		scope=>'participant',

		enabled=>0, # user can not change the metric, no schema.

		in_database=>1

		};

	    push @user_metrics, $metric;

	}

	$self->{usermetrics}->{$username} = \@user_metrics;

    }

    push @user_metrics, $self->_get_built_in_user_metrics($username);

    return @user_metrics;

}

# Returns the user metrics as a collection of references to hashs. 

sub get_user_metrics_totals {

    my ($self,@users) = @_;

    my @user_metrics;

    if (exists($self->{usermetrics_totals})) {

	@user_metrics = @$self->{usermetrics_totals};

    }

    my @total_metrics;

    foreach my $user (@users) {

	my @metrics = $self->get_user_metrics($user);

	if (scalar(@total_metrics) == 0) {

	    # Copy the metrics in.

	    foreach my $metric (@metrics) {

		my %temp = %$metric;

		push @total_metrics, \%temp;

	    }

	}

	else {

	    # Add them up!

	    for (my $index = 0; $index < scalar(@total_metrics) ; ++$index) {

		if ($metrics[$index]->{value} ne '') {

		    if ($total_metrics[$index]->{value} eq '') {

			$total_metrics[$index]->{value} = 0;

		    }

		    $total_metrics[$index]->{value} +=

			$metrics[$index]->{value};		

		}

	    }

	}

    }

    $self->{usermetrics_totals}= \@total_metrics;

    return @total_metrics;

}

# Returns a list of hashes. Each hash is an event. In the hash is stored who 

# caused the event, when it happened, and what happened. The hashes are defined

# as: 

#   email -> the email address of the user who caused the event.

#   date  -> when the event happened.

#   description -> the event description.

#

# The topic must be loaded from the db before this function can be called.

sub get_topic_history {

    my ($self) = @_;

    my @topic_history = $self->_get_topic_history_rows();

    my @event_list;

    my $last_history_row;

    foreach my $current_history_row (@topic_history) {

	if ( !defined($last_history_row) ) {

	    # The first event is always the topic creation, so lets make 

	    # that now.

	    my $filteredemail = 

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

	    my $formatted_time = 

	        Codestriker->format_short_timestamp($current_history_row->{modified_ts});

	    push @event_list, 

	    { 

		email=>$filteredemail,

		date =>$formatted_time,

		description=>'The topic is created.' 

	    };

	}

	else {

	    my %event = 

	    ( 

		email=> Codestriker->filter_email(

			$current_history_row->{modified_by}),

		date => Codestriker->format_short_timestamp(

			$current_history_row->{modified_ts}),

		description=>'' 

	    );

	    # Look for changes in all of the fields. Several fields could have 

	    # changed at once.

	    if ($current_history_row->{author} ne $last_history_row->{author}) {

		my %new_event = %event;

		$new_event{description} = 

		    "Author changed: $last_history_row->{author} to " . 

		    "$current_history_row->{author}.";

		push @event_list, \%new_event;

	    }

	    if ($current_history_row->{title} ne $last_history_row->{title}) {

		my %new_event = %event;

		$new_event{description} = 

		    "Title changed to: \"$current_history_row->{title}\".";

		push @event_list, \%new_event;

	    }

	    if ($current_history_row->{description} ne $last_history_row->{description}) {

		my %new_event = %event;

		$new_event{description} = "Description changed to: " . 

		    "$current_history_row->{description}.";

		push @event_list, \%new_event;

	    }

	    if ($current_history_row->{state} ne $last_history_row->{state}) {

		my %new_event = %event;

		$new_event{description} = 

		    "Topic state changed to: " . 

		    $Codestriker::topic_states[$current_history_row->{state}];

		push @event_list, \%new_event;

	    }

	    if ($current_history_row->{repository} ne $last_history_row->{repository}) {

		my %new_event = %event;

		$new_event{description} = 

		    "Repository changed to: $current_history_row->{repository}.";

		push @event_list, \%new_event;

	    }

	    if ($current_history_row->{project} ne $last_history_row->{project}) {

		my %new_event = %event;

		$new_event{description} = 

		    "Project changed to: $current_history_row->{project}.";

		push @event_list, \%new_event;

	    }

	    if ($current_history_row->{reviewers} ne $last_history_row->{reviewers}) {

		my %new_event = %event;

		# Figure out who was removed, and who was added to the list.

		my @reviewers = split /,/,$current_history_row->{reviewers};

		my @l_reviewers = split /,/,$last_history_row->{reviewers};

		my @new;

		my @removed;

                Codestriker::set_differences(\@reviewers, \@l_reviewers, \@new, \@removed);

		if (@new == 0) {

    		    $new_event{description} = 

			"Reviewers removed: " . join(',',@removed);;

		}

		elsif (@removed == 0) {

    		    $new_event{description} = 

			"Reviewers added: " . join(',',@new);

		}

		else {

    		    $new_event{description} = 

			"Reviewers added: " . join(',',@new) . 

			" and reviewers removed: " . join(',',@removed);

		}

		push @event_list, \%new_event;

	    }

	    if ($current_history_row->{cc} ne $last_history_row->{cc}) {

		my %new_event = %event;

		$new_event{description} = 

		    "CC changed to $current_history_row->{cc}.";

		push @event_list, \%new_event;

	    }

	}

	$last_history_row = $current_history_row

    }

    return @event_list;

}

# Returns the topic metrics as a collection of references to

# hashes. The hash that is returned has the same keys as the

# metrics_schema hash, plus a value key. This private function

# returns "built in" metrics derived from the topic history

# table.

sub _get_built_in_topic_metrics {

    my $self = shift;

    my @topic_metrics;

    my @topic_history = $self->_get_topic_history_rows();

    my %state_times;

    my $last_history_row;

    # Figure out how long the topic has spent in each state.

    for ( my $topic_history_index = 0; 

	  $topic_history_index <= scalar(@topic_history);

	  ++$topic_history_index) {

	my $current_history_row;

	if ($topic_history_index < scalar(@topic_history)) {

	    $current_history_row = $topic_history[$topic_history_index];

	}

	if (defined($last_history_row)) {

	    my $start = 

		Codestriker->convert_date_timestamp_time( 

		    $last_history_row->{modified_ts});

	    my $end   = 0;

	    if (defined($current_history_row)) {

		$end = Codestriker->convert_date_timestamp_time( 

		    $current_history_row->{modified_ts});

	    }

	    else {

		$end = time();

	    }

	    if (exists($state_times{$last_history_row->{state}})) {

		$state_times{$last_history_row->{state}} += $end - $start;

	    }

	    else {

		$state_times{$last_history_row->{state}} = $end - $start;

	    }

	}

	$last_history_row = $current_history_row

    }

    foreach my $state ( sort keys %state_times) {

	my $statename = $Codestriker::topic_states[$state];

	my $time_days = sprintf("%1.1f",$state_times{$state} / (60*60*24));

	# This is the topic metric.

	my $metric =

	    {

	    name         => 'Time In ' . $statename,

	    description  => 

		'Time in days the topic spent in the ' . $statename . ' state.',

	    value        => $time_days,

	    # User can not change the metric, not configured.

	    enabled      => 0,

	    in_database  => 0,

	    filter       =>"count",

	    builtin      => 1,

	    };	

	push @topic_metrics, $metric;

    }

    return @topic_metrics;

}

# Returns the user topic metrics as a collection of references to

# hashs. The hash that is returned has the same keys as the

# metrics_schema hash, plus a value key. This private function

# returns "built in" metrics derived from the topic history

# table and the topic view history table.

sub _get_built_in_user_metrics {

    my ($self,$username) = @_;

    my @user_metrics;

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

    # Setup the prepared statements.

    my $select_topic = $dbh->prepare_cached('SELECT creation_ts ' .

					    'FROM topicviewhistory ' .

					    'WHERE topicid = ? AND ' .

					    'LOWER(email) = LOWER(?) ' .

					    'ORDER BY creation_ts');

    $select_topic->execute($self->{topicid}, $username);

#    my $total_time = $self->calculate_topic_view_time($select_topic);

    my $total_time = 0;

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

    if ($total_time == 0) {

	$total_time = "";

    }

    else {

	$total_time = sprintf("%1.0f",$total_time / (60));

    }

    # This is the topic metric.

    my $metric =

	{

	name         => 'Codestriker Time',

	description  => 

	    'Time in minutes spent in Codestriker looking at this topic.',

	value        => $total_time,

	enabled      => 0,

	in_database  => 0,

	filter       =>"minutes",

	builtin      => 1,

	scope        =>'participant',

	};	

    push @user_metrics, $metric;

    return @user_metrics;

}

# Given a DBI statement that returns a sorted collection of timestamps from 

# the topicviewhistory table, return the total time.

sub calculate_topic_view_time {

    my ($self,$select_topic) = @_;

    # The amount of time you give to people after a click assuming no other

    # clicks are after it.

    my $time_increment = 4*60;

    my $total_time = 0;

    my $last_time = 0;    

    while ( my @row_array = $select_topic->fetchrow_array) {

	my ($creation_ts) = @row_array;

	my $time = Codestriker->convert_date_timestamp_time($creation_ts);

	if ($last_time) {

	    if ($time - $last_time > $time_increment) {

		$total_time += $time_increment

	    }

	    else {

		$total_time += $time - $last_time;

	    }

	}

	$last_time = $time;

    }

    if ($last_time) {

	$total_time += $time_increment;

    }

    return $total_time;

}

# Returns the topichistory rows as an array of hashes. Each element in the 

# array is a row, each field in the table is a key. It will only fetch if 

# from the db once.

sub _get_topic_history_rows {

    my ($self) = @_;

    if (defined( $self->{topichistoryrows}))  {

	return @{$self->{topichistoryrows}};

    }

    else {

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

	my @history_list;

	# Setup the prepared statements.

	my $select_topic = $dbh->prepare_cached('SELECT topichistory.author, ' .

						'topichistory.title, ' .

						'topichistory.description, ' .

						'topichistory.state, ' .

						'topichistory.modified_ts, ' .

						'topichistory.version, ' .

						'topichistory.repository, ' .

						'project.name, ' .

						'topichistory.reviewers, ' .

						'topichistory.cc, ' .

						'topichistory.modified_by_user ' .

						'FROM topichistory, project ' .

						'WHERE topichistory.topicid = ? AND ' .

						'topichistory.projectid = project.id ' .

						'ORDER BY topichistory.version');

	$select_topic->execute($self->{topicid});

	while ( my @row_array = $select_topic->fetchrow_array) {

	    my ($author,$title,$description,$state,$modified_ts, $version,

		$repository,$project,$reviewers,$cc, $modified_by) = @row_array;

	    my %entry = ( 

	      author=>$author,

	      title=>decode_utf8($title),

	      description=>decode_utf8($description),

	      state=>$state,

	      modified_ts=>$modified_ts,

	      version=>$version,

	      repository=>$repository,

	      project=>decode_utf8($project),

	      reviewers=>lc($reviewers),

	      cc=>lc($cc), 

	      modified_by=>lc($modified_by)

	      );

	    push @history_list, \%entry;

	}

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

	$self->{topichistoryrows} = \@history_list;

	return @history_list;

    }

}

# Returns an error message if a number is not a valid value for a given metric.

sub _verify_metric {

    my ($self, $metric, $value) = @_;

    my $msg = '';

    if ($metric->{enabled}) {

	my $input_ok = 0;

	if ($metric->{filter} eq "hours") {

	    $input_ok = ($value =~ /(^[\d]+([\.:][\d]*)?$)|(^$)/);

	    $msg = $metric->{name} .

		   " must be a valid time in hours. " . HTML::Entities::encode($value) . " was " . 

	           "not saved.<BR>" unless $input_ok;

	}

	elsif ($metric->{filter} eq "minutes") {

	    $input_ok = ($value =~ /(^[\d]+)|(^$)/);

	    $msg = $metric->{name} .

		   " must be a valid time in minutes. " . HTML::Entities::encode($value) . " was " . 

	           "not saved.<BR>" unless $input_ok;

	}

	elsif ($metric->{filter} eq "count") {

	    $input_ok = ($value =~ /(^[\d]+$)|(^$)/);

	    $msg = $metric->{name} . 

		   " must be a valid count. " . HTML::Entities::encode($value) . " was not " . 

	           "saved.<BR>" unless $input_ok;

	}

	elsif ($metric->{filter} eq "percent") {

	    $input_ok = ($value =~ /(^[\d]+(\.[\d]*)?$)|(^$)/);

	    if ($input_ok && $value ne '') {

		$input_ok = 0 unless ($value >= 0.0 && $value <= 100.0);

	    }

	    $msg = $metric->{name} . 

		   " must be a valid percent, between 0 and 100. " . 

	           HTML::Entities::encode($value) . " was not saved.<BR>" unless $input_ok;

	}

	else {

	    # invalid config.

	    $input_ok = 0;

	    $msg = HTML::Entities::encode($metric->{name}) . 

		   " invalid filter type in configuration. Must " . 

	           "be hours, count, or percent.<BR>";

	}

    }

    return $msg;

}

# Stores all of the metrics to the database.

sub store {

    my ($self) = @_;

    $self->_store_topic_metrics();

    $self->_store_user_metrics();

}

# Stores the topic metrics to the database.

sub _store_user_metrics {

    my ($self) = @_;

    foreach my $user (keys %{$self->{usermetrics}}) {

	$self->get_user_metrics($user);

    }

    # Obtain a database connection.

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

    # flush out the user metrics from the topic,

    my $delete_alluser_metric =

	$dbh->prepare_cached('DELETE FROM topicusermetric ' .

			     'WHERE topicid = ?');

    $delete_alluser_metric->execute($self->{topicid});

    my $insert_user_metric =

	$dbh->prepare_cached('INSERT INTO topicusermetric (topicid, 

						    email, 

						    metric_name, 

						    value) ' .

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

    foreach my $user (keys %{$self->{usermetrics}}) {

	my @metrics = $self->get_user_metrics($user);

	foreach my $metric (@metrics) {

	    next if ($metric->{builtin});

	    if ($metric->{value} ne '') {

		$insert_user_metric->execute($self->{topicid}, 

					     $user, 

					     $metric->{name}, 

					     $metric->{value});	    

	    }

	}

    }

    # Close the connection, and check for any database errors.

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

}

# Stores the topic metrics to the database.

sub _store_topic_metrics {

    my ($self) = @_;

    # Obtain a database connection.

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

    # Store the topic metrics first.

    my @topic_metrics = $self->get_topic_metrics();

    my $insert_topic_metric =

	$dbh->prepare_cached('INSERT INTO topicmetric (topicid, 

						       metric_name, 

						       value) ' .

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

    my $update_topic_metric =

	$dbh->prepare_cached('UPDATE topicmetric SET value = ? ' .

			     'WHERE topicid = ? and metric_name = ?');

    my $delete_topic_metric =

	$dbh->prepare_cached('DELETE FROM topicmetric ' .

			     'WHERE topicid = ? and metric_name = ?');

    foreach my $metric (@topic_metrics) {

	# don't save built in metrics

	next if ($metric->{builtin});

	if ($metric->{in_database}) {