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}) {

            if ($metric->{value} ne '') {
                $update_topic_metric->execute($metric->{value}, 
                                              $self->{topicid}, 
                                              $metric->{name});
            }
            else {
                # Delete the row.
                $delete_topic_metric->execute($self->{topicid},
                                              $metric->{name});
                $metric->{in_database} = 0;
            }
        }
        else {

            # New metric that is not in the datbase.
            if ($metric->{value} ne '') {
                $insert_topic_metric->execute($self->{topicid}, 
                                              $metric->{name},
                                              $metric->{value});
                $metric->{in_database} = 1;
            }
        }

        $metric->{in_database} = 1;
    }

    # Close the connection, and check for any database errors.
    Codestriker::DB::DBI->release_connection($dbh, 1);
}

1;